terminalhire 0.1.1 → 0.2.2

package/dist/bin/jpi-refresh.js

@@ -0,0 +1,1897 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../packages/core/src/types.ts
+var init_types = __esm({
+  "../../packages/core/src/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/core/src/vocabulary.ts
+function normalize(tokens) {
+  const result = /* @__PURE__ */ new Set();
+  for (const raw of tokens) {
+    const lower = raw.toLowerCase().trim();
+    if (VOCAB_SET.has(lower)) {
+      result.add(lower);
+      continue;
+    }
+    const mapped = SYNONYMS[lower];
+    if (mapped && VOCAB_SET.has(mapped)) {
+      result.add(mapped);
+    }
+  }
+  return Array.from(result);
+}
+var VOCABULARY, SYNONYMS, VOCAB_SET;
+var init_vocabulary = __esm({
+  "../../packages/core/src/vocabulary.ts"() {
+    "use strict";
+    VOCABULARY = [
+      // Languages
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "java",
+      "ruby",
+      "elixir",
+      "scala",
+      "kotlin",
+      "swift",
+      "cpp",
+      "csharp",
+      "php",
+      "haskell",
+      "clojure",
+      "r",
+      // Frontend frameworks / libs
+      "react",
+      "nextjs",
+      "vue",
+      "nuxt",
+      "svelte",
+      "angular",
+      "solidjs",
+      "tailwind",
+      "css",
+      "html",
+      "graphql",
+      "trpc",
+      // Backend frameworks
+      "nodejs",
+      "express",
+      "fastify",
+      "nestjs",
+      "django",
+      "fastapi",
+      "flask",
+      "rails",
+      "spring",
+      "actix",
+      "gin",
+      "phoenix",
+      "laravel",
+      "dotnet",
+      // Infrastructure & DevOps
+      "kubernetes",
+      "docker",
+      "terraform",
+      "aws",
+      "gcp",
+      "azure",
+      "ci-cd",
+      "github-actions",
+      "linux",
+      "nginx",
+      "pulumi",
+      "ansible",
+      "prometheus",
+      "grafana",
+      "datadog",
+      "opentelemetry",
+      // Data & ML
+      "postgresql",
+      "mysql",
+      "sqlite",
+      "mongodb",
+      "redis",
+      "elasticsearch",
+      "kafka",
+      "rabbitmq",
+      "data-engineering",
+      "spark",
+      "airflow",
+      "dbt",
+      "ml",
+      "llm",
+      "pytorch",
+      "tensorflow",
+      "pandas",
+      "numpy",
+      // Domains / capabilities
+      "oauth",
+      "authentication",
+      "security",
+      "payments",
+      "billing",
+      "frontend",
+      "backend",
+      "devops",
+      "mobile",
+      "ios",
+      "android",
+      "api-design",
+      "microservices",
+      "websockets",
+      "testing",
+      "accessibility",
+      "seo",
+      "performance",
+      "observability",
+      "search",
+      "realtime"
+    ];
+    SYNONYMS = {
+      // Kubernetes aliases
+      "k8s": "kubernetes",
+      "kube": "kubernetes",
+      // Auth / identity
+      "passport": "authentication",
+      "oauth2": "oauth",
+      "oidc": "oauth",
+      "jwt": "authentication",
+      "saml": "authentication",
+      "auth0": "authentication",
+      "clerk": "authentication",
+      "nextauth": "authentication",
+      // Payments
+      "@stripe/stripe-js": "payments",
+      "stripe": "payments",
+      "braintree": "payments",
+      "paddle": "payments",
+      "lemonsqueezy": "payments",
+      "recurly": "billing",
+      "chargebee": "billing",
+      // Framework / lib aliases
+      "next": "nextjs",
+      "next.js": "nextjs",
+      "nuxt.js": "nuxt",
+      "vue.js": "vue",
+      "angular.js": "angular",
+      "angularjs": "angular",
+      "express.js": "express",
+      "expressjs": "express",
+      "fastapi": "fastapi",
+      "nest": "nestjs",
+      "nest.js": "nestjs",
+      "sveltekit": "svelte",
+      // Language aliases
+      "ts": "typescript",
+      "js": "javascript",
+      "py": "python",
+      "golang": "go",
+      "c++": "cpp",
+      "c#": "csharp",
+      ".net": "dotnet",
+      "asp.net": "dotnet",
+      // DB aliases
+      "postgres": "postgresql",
+      "pg": "postgresql",
+      "mongo": "mongodb",
+      "elastic": "elasticsearch",
+      // Cloud aliases
+      "amazon web services": "aws",
+      "google cloud": "gcp",
+      "google cloud platform": "gcp",
+      "microsoft azure": "azure",
+      // CI/CD aliases
+      "github actions": "github-actions",
+      "circle ci": "ci-cd",
+      "circleci": "ci-cd",
+      "jenkins": "ci-cd",
+      "gitlab ci": "ci-cd",
+      "travis": "ci-cd",
+      // Mobile
+      "react native": "mobile",
+      "flutter": "mobile",
+      "expo": "mobile",
+      // AI / ML
+      "openai": "llm",
+      "anthropic": "llm",
+      "langchain": "llm",
+      "llamaindex": "llm",
+      "hugging face": "ml",
+      "huggingface": "ml",
+      "scikit-learn": "ml",
+      "sklearn": "ml",
+      // Data pipeline
+      "apache kafka": "kafka",
+      "apache spark": "spark",
+      "apache airflow": "airflow",
+      // Misc
+      "tailwindcss": "tailwind",
+      "tw": "tailwind",
+      "gql": "graphql",
+      "ws": "websockets",
+      "socket.io": "websockets",
+      "jest": "testing",
+      "vitest": "testing",
+      "playwright": "testing",
+      "cypress": "testing"
+    };
+    VOCAB_SET = new Set(VOCABULARY);
+  }
+});
+
+// ../../packages/core/src/matcher.ts
+function computeIdf(jobs) {
+  const docFreq = /* @__PURE__ */ new Map();
+  const N = jobs.length;
+  for (const job of jobs) {
+    const unique = new Set(job.tags);
+    for (const tag of unique) {
+      docFreq.set(tag, (docFreq.get(tag) ?? 0) + 1);
+    }
+  }
+  const idf = /* @__PURE__ */ new Map();
+  for (const [tag, df] of docFreq) {
+    idf.set(tag, Math.log((N + 1) / (df + 1)) + 1);
+  }
+  return idf;
+}
+function inferSeniority(title) {
+  for (const [re, level] of SENIORITY_PATTERNS) {
+    if (re.test(title)) return level;
+  }
+  return void 0;
+}
+function seniorityScore(fp, job) {
+  if (!fp.seniorityBand) return 1;
+  const jobLevel = inferSeniority(job.title);
+  if (!jobLevel) return 0.85;
+  const wanted = SENIORITY_RANK[fp.seniorityBand] ?? 1;
+  const got = SENIORITY_RANK[jobLevel] ?? 1;
+  const delta = Math.abs(wanted - got);
+  if (delta === 0) return 1;
+  if (delta === 1) return 0.5;
+  return 0.2;
+}
+function recencyScore(postedAt) {
+  if (!postedAt) return 0.75;
+  const ageDays = (Date.now() - new Date(postedAt).getTime()) / 864e5;
+  if (ageDays < 7) return 1;
+  if (ageDays < 30) return 0.9;
+  if (ageDays < 90) return 0.75;
+  return 0.6;
+}
+function passesFilters(fp, job) {
+  const prefs = fp.prefs;
+  if (!prefs) return true;
+  if (prefs.remoteOnly && !job.remote) return false;
+  if (prefs.roleTypes && prefs.roleTypes.length > 0 && !prefs.roleTypes.includes(job.roleType)) {
+    return false;
+  }
+  if (prefs.compFloorUsd !== void 0) {
+    if (job.compMax !== void 0 && job.compMax < prefs.compFloorUsd) return false;
+  }
+  return true;
+}
+function buildReason(matchedTags) {
+  if (matchedTags.length === 0) return "No direct skill overlap found.";
+  const top = matchedTags.slice(0, 3);
+  const rest = matchedTags.length - top.length;
+  const listed = top.join(", ");
+  if (rest === 0) return `Matched on ${listed}.`;
+  return `Matched on ${listed} + ${rest} more skill${rest > 1 ? "s" : ""}.`;
+}
+function match(fp, jobs, limit = 5) {
+  const idf = computeIdf(jobs);
+  const fpTagSet = new Set(fp.skillTags);
+  const maxTagScore = fp.skillTags.reduce((acc, t) => acc + (idf.get(t) ?? 1), 0);
+  const candidates = jobs.filter((j) => passesFilters(fp, j));
+  const scored = candidates.map((job) => {
+    const jobTagSet = new Set(job.tags);
+    const matched = [];
+    let tagScore2 = 0;
+    for (const tag of fpTagSet) {
+      if (jobTagSet.has(tag)) {
+        const w = idf.get(tag) ?? 1;
+        tagScore2 += w;
+        matched.push(tag);
+      }
+    }
+    const normTagScore = maxTagScore > 0 ? tagScore2 / maxTagScore : 0;
+    matched.sort((a, b) => (idf.get(b) ?? 1) - (idf.get(a) ?? 1));
+    const sScore = seniorityScore(fp, job);
+    const rScore = recencyScore(job.postedAt);
+    const score = normTagScore * 0.6 + sScore * 0.25 + rScore * 0.15;
+    return {
+      job,
+      score: Math.round(score * 1e3) / 1e3,
+      matchedTags: matched,
+      reason: buildReason(matched)
+    };
+  });
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function matchOne(fp, job) {
+  const results = match(fp, [job], 1);
+  return results.length > 0 ? results[0] : null;
+}
+var SENIORITY_RANK, SENIORITY_PATTERNS;
+var init_matcher = __esm({
+  "../../packages/core/src/matcher.ts"() {
+    "use strict";
+    SENIORITY_RANK = {
+      junior: 0,
+      mid: 1,
+      senior: 2,
+      staff: 3
+    };
+    SENIORITY_PATTERNS = [
+      [/\bstaff\b|\bprincipal\b|\bdistinguished\b/i, "staff"],
+      [/\bsenior\b|\bsr\.?\b/i, "senior"],
+      [/\bjunior\b|\bjr\.?\b|\bentry[\s-]?level\b/i, "junior"],
+      [/\bmid[\s-]?level\b|\bmid\b/i, "mid"]
+    ];
+  }
+});
+
+// ../../packages/core/src/feeds/greenhouse.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.\-+#]/g, " ").split(/\s+/).filter(Boolean);
+}
+function extractTags(job) {
+  const texts = [
+    job.title,
+    ...(job.departments ?? []).map((d) => d.name),
+    job.location?.name ?? "",
+    ...(job.offices ?? []).map((o) => o.name),
+    // mine the full HTML description for additional signal when present
+    ...job.content ? [job.content.replace(/<[^>]*>/g, " ")] : []
+  ].filter(Boolean);
+  const tokens = texts.flatMap(tokenize);
+  return normalize(tokens);
+}
+function inferRemote(location) {
+  const l = location.toLowerCase();
+  return l.includes("remote") || l.includes("anywhere") || l.includes("worldwide");
+}
+async function fetchSlug(slug) {
+  const url = `https://boards-api.greenhouse.io/v1/boards/${slug}/jobs?content=true`;
+  let res;
+  try {
+    res = await fetch(url, { headers: { Accept: "application/json" } });
+  } catch (err) {
+    console.warn(`[greenhouse] ${slug}: network error \u2014`, err);
+    return [];
+  }
+  if (!res.ok) {
+    console.warn(`[greenhouse] ${slug}: HTTP ${res.status} ${res.statusText}`);
+    return [];
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch (err) {
+    console.warn(`[greenhouse] ${slug}: JSON parse error \u2014`, err);
+    return [];
+  }
+  const jobs = data.jobs ?? [];
+  if (jobs.length === 0) {
+    console.warn(`[greenhouse] ${slug}: 0 jobs returned (board may be private or slug invalid)`);
+  } else {
+    console.info(`[greenhouse] ${slug}: ${jobs.length} jobs`);
+  }
+  return jobs.map((j) => ({
+    id: `greenhouse:${j.id}`,
+    source: "greenhouse",
+    title: j.title,
+    company: slug,
+    url: j.absolute_url,
+    remote: inferRemote(j.location?.name ?? ""),
+    location: j.location?.name,
+    tags: extractTags(j),
+    roleType: "full_time",
+    postedAt: j.updated_at,
+    applyMode: "direct",
+    raw: j
+  }));
+}
+var FALLBACK_SLUGS, greenhouse;
+var init_greenhouse = __esm({
+  "../../packages/core/src/feeds/greenhouse.ts"() {
+    "use strict";
+    init_vocabulary();
+    FALLBACK_SLUGS = [
+      "stripe",
+      "linear",
+      "vercel",
+      "ramp",
+      "notion",
+      "airbnb",
+      "anthropic",
+      "figma",
+      "discord",
+      "brex",
+      "mercury",
+      "retool",
+      "vanta",
+      "plaid",
+      "gusto",
+      "scale",
+      "databricks",
+      "coinbase",
+      "robinhood",
+      "doordash"
+    ];
+    greenhouse = {
+      source: "greenhouse",
+      async fetch(opts) {
+        const slugs = opts?.slugs && opts.slugs.length > 0 ? opts.slugs : FALLBACK_SLUGS;
+        console.info(`[greenhouse] fetching ${slugs.length} slugs: ${slugs.join(", ")}`);
+        const results = await Promise.allSettled(slugs.map(fetchSlug));
+        const jobs = [];
+        let failures = 0;
+        for (const r of results) {
+          if (r.status === "fulfilled") {
+            jobs.push(...r.value);
+          } else {
+            failures++;
+            console.warn(`[greenhouse] slug fetch rejected:`, r.reason);
+          }
+        }
+        console.info(`[greenhouse] total: ${jobs.length} jobs, ${failures} slug failures`);
+        return jobs;
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/feeds/ashby.ts
+function tokenize2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.\-+#]/g, " ").split(/\s+/).filter(Boolean);
+}
+function extractTags2(job) {
+  const texts = [
+    job.title,
+    job.teamName ?? "",
+    job.locationName ?? "",
+    ...(job.secondaryLocations ?? []).map((l) => l.locationName ?? "")
+  ];
+  return normalize(texts.flatMap(tokenize2));
+}
+function mapEmploymentType(raw) {
+  if (!raw) return "full_time";
+  const lower = raw.toLowerCase();
+  if (lower.includes("contract") || lower.includes("contractor")) return "contract";
+  if (lower.includes("freelance")) return "freelance";
+  return "full_time";
+}
+function inferRemote2(job) {
+  if (job.isRemote === true) return true;
+  const loc = (job.locationName ?? "").toLowerCase();
+  return loc.includes("remote") || loc.includes("anywhere");
+}
+async function fetchSlug2(slug) {
+  const url = `https://api.ashbyhq.com/posting-api/job-board/${slug}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Ashby ${slug}: HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return (data.jobs ?? []).map((j) => {
+    const comp = j.compensation;
+    return {
+      id: `ashby:${j.id}`,
+      source: "ashby",
+      title: j.title,
+      company: slug,
+      url: j.applyUrl ?? `https://jobs.ashbyhq.com/${slug}/${j.id}`,
+      remote: inferRemote2(j),
+      location: j.locationName,
+      compMin: comp?.minValue,
+      compMax: comp?.maxValue,
+      tags: extractTags2(j),
+      roleType: mapEmploymentType(j.employmentType),
+      postedAt: j.publishedDate,
+      applyMode: "direct",
+      raw: j
+    };
+  });
+}
+var ashby;
+var init_ashby = __esm({
+  "../../packages/core/src/feeds/ashby.ts"() {
+    "use strict";
+    init_vocabulary();
+    ashby = {
+      source: "ashby",
+      async fetch(opts) {
+        const slugs = opts?.slugs ?? [];
+        const results = await Promise.allSettled(slugs.map(fetchSlug2));
+        const jobs = [];
+        for (const r of results) {
+          if (r.status === "fulfilled") jobs.push(...r.value);
+        }
+        return jobs;
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/feeds/himalayas.ts
+function tokenize3(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.\-+#]/g, " ").split(/\s+/).filter(Boolean);
+}
+function extractTags3(job) {
+  const texts = [
+    job.title,
+    ...job.tags ?? []
+  ];
+  return normalize(texts.flatMap(tokenize3));
+}
+function mapJobType(raw) {
+  if (!raw) return "full_time";
+  const lower = raw.toLowerCase();
+  if (lower.includes("contract")) return "contract";
+  if (lower.includes("freelance")) return "freelance";
+  return "full_time";
+}
+function buildUrl(job) {
+  if (job.applicationUrl) return job.applicationUrl;
+  if (job.url) return job.url;
+  const slug = job.slug ?? job.id ?? "unknown";
+  return `https://himalayas.app/jobs/${slug}`;
+}
+function buildId(job) {
+  return `himalayas:${job.id ?? job.slug ?? job.title}`;
+}
+var himalayas;
+var init_himalayas = __esm({
+  "../../packages/core/src/feeds/himalayas.ts"() {
+    "use strict";
+    init_vocabulary();
+    himalayas = {
+      source: "himalayas",
+      async fetch(opts) {
+        const limit = opts?.limit ?? 100;
+        const url = `https://himalayas.app/jobs/api?limit=${limit}`;
+        const res = await fetch(url, {
+          headers: { Accept: "application/json" }
+        });
+        if (!res.ok) {
+          throw new Error(`Himalayas: HTTP ${res.status}`);
+        }
+        const data = await res.json();
+        return (data.jobs ?? []).map((j) => ({
+          id: buildId(j),
+          source: "himalayas",
+          title: j.title,
+          company: j.companyName ?? j.companySlug ?? "unknown",
+          url: buildUrl(j),
+          // Himalayas is a remote-only board
+          remote: true,
+          location: (j.locationRestrictions ?? []).join(", ") || "Remote",
+          compMin: j.salaryMin,
+          compMax: j.salaryMax,
+          tags: extractTags3(j),
+          roleType: mapJobType(j.jobType),
+          postedAt: j.pubDate ?? j.createdAt,
+          applyMode: "direct",
+          raw: j
+        }));
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/feeds/wwr.ts
+function tokenize4(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.\-+#]/g, " ").split(/\s+/).filter(Boolean);
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function inferRoleType(category) {
+  const lower = category.toLowerCase();
+  if (lower.includes("contract")) return "contract";
+  if (lower.includes("freelance")) return "freelance";
+  return "full_time";
+}
+function extractId(link) {
+  const match2 = link.match(/\/opening\/([^/\s]+)/);
+  return `wwr:${match2?.[1] ?? encodeURIComponent(link)}`;
+}
+function parseRss(xml) {
+  const items = [];
+  const itemBlocks = xml.match(/<item>([\s\S]*?)<\/item>/g) ?? [];
+  for (const block of itemBlocks) {
+    const get = (tag) => {
+      const cdataMatch = block.match(new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>`, "i"));
+      if (cdataMatch) return cdataMatch[1].trim();
+      const plainMatch = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"));
+      return plainMatch?.[1].trim() ?? "";
+    };
+    const rawTitle = get("title");
+    const colonIdx = rawTitle.indexOf(":");
+    const company = colonIdx !== -1 ? rawTitle.slice(0, colonIdx).trim() : "Unknown";
+    const titleAfterColon = colonIdx !== -1 ? rawTitle.slice(colonIdx + 1).trim() : rawTitle;
+    const title = titleAfterColon.replace(/\s*\([^)]*\)\s*$/, "").trim();
+    items.push({
+      title,
+      link: get("link") || get("guid"),
+      pubDate: get("pubDate"),
+      category: get("category"),
+      description: get("description"),
+      company
+    });
+  }
+  return items;
+}
+function extractTags4(item) {
+  const text = [item.title, item.category, stripHtml(item.description)].join(" ");
+  return normalize(tokenize4(text));
+}
+var WWR_RSS_URL, wwr;
+var init_wwr = __esm({
+  "../../packages/core/src/feeds/wwr.ts"() {
+    "use strict";
+    init_vocabulary();
+    WWR_RSS_URL = "https://weworkremotely.com/remote-jobs.rss";
+    wwr = {
+      source: "wwr",
+      async fetch(opts) {
+        const limit = opts?.limit ?? 200;
+        const res = await fetch(WWR_RSS_URL, {
+          headers: { Accept: "application/rss+xml, application/xml, text/xml" }
+        });
+        if (!res.ok) {
+          throw new Error(`WWR RSS: HTTP ${res.status}`);
+        }
+        const xml = await res.text();
+        const items = parseRss(xml).slice(0, limit);
+        return items.map((item) => ({
+          id: extractId(item.link),
+          source: "wwr",
+          title: item.title,
+          company: item.company,
+          url: item.link,
+          // WWR is a remote-only board
+          remote: true,
+          location: "Remote",
+          tags: extractTags4(item),
+          roleType: inferRoleType(item.category),
+          postedAt: item.pubDate ? new Date(item.pubDate).toISOString() : void 0,
+          applyMode: "direct",
+          raw: item
+        }));
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/feeds/hn.ts
+function tokenize5(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.\-+#]/g, " ").split(/\s+/).filter(Boolean);
+}
+function stripHtml2(html) {
+  return html.replace(/<p>/gi, " ").replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/\s+/g, " ").trim();
+}
+function extractUrl(text) {
+  const match2 = text.match(/https?:\/\/[^\s<>"']+/);
+  return match2?.[0] ?? "";
+}
+function inferRemote3(text) {
+  const lower = text.toLowerCase();
+  return lower.includes("remote") || lower.includes("anywhere") || lower.includes("distributed");
+}
+function inferRoleType2(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("contract") || lower.includes("contractor")) return "contract";
+  if (lower.includes("freelance")) return "freelance";
+  return "full_time";
+}
+function parseComment(item) {
+  if (!item.text || item.text.trim().length < 20) return null;
+  const raw = stripHtml2(item.text);
+  if (!raw) return null;
+  const firstLine = raw.split(/\n/)[0];
+  const parts = firstLine.split("|").map((s) => s.trim());
+  const company = parts[0] ?? "Unknown";
+  const title = parts[1] ?? firstLine.slice(0, 80).trim();
+  const location = parts[2] ?? "";
+  if (company.toLowerCase().startsWith("note:") || company.toLowerCase().startsWith("ps:") || title.length < 3) {
+    return null;
+  }
+  const url = extractUrl(raw) || `https://news.ycombinator.com/item?id=${item.id}`;
+  const tags = extractTags5(raw);
+  if (tags.length === 0) return null;
+  return {
+    id: `hn:${item.id}`,
+    source: "hn",
+    title: title.slice(0, 120),
+    company: company.slice(0, 80),
+    url,
+    remote: inferRemote3(raw),
+    location: location || void 0,
+    tags,
+    roleType: inferRoleType2(raw),
+    postedAt: item.created_at,
+    applyMode: "direct",
+    raw: item
+  };
+}
+function extractTags5(text) {
+  return normalize(tokenize5(text));
+}
+var ALGOLIA_SEARCH, ALGOLIA_ITEMS, hn;
+var init_hn = __esm({
+  "../../packages/core/src/feeds/hn.ts"() {
+    "use strict";
+    init_vocabulary();
+    ALGOLIA_SEARCH = "https://hn.algolia.com/api/v1/search?query=Ask+HN%3A+Who+is+Hiring%3F&tags=story,ask_hn&hitsPerPage=1";
+    ALGOLIA_ITEMS = "https://hn.algolia.com/api/v1/items/";
+    hn = {
+      source: "hn",
+      async fetch(opts) {
+        const limit = opts?.limit ?? 150;
+        const searchRes = await fetch(ALGOLIA_SEARCH, {
+          headers: { Accept: "application/json" }
+        });
+        if (!searchRes.ok) {
+          throw new Error(`HN Algolia search: HTTP ${searchRes.status}`);
+        }
+        const searchData = await searchRes.json();
+        const story = searchData.hits[0];
+        if (!story) {
+          throw new Error('HN: No "Who is Hiring" story found');
+        }
+        const itemRes = await fetch(`${ALGOLIA_ITEMS}${story.objectID}`, {
+          headers: { Accept: "application/json" }
+        });
+        if (!itemRes.ok) {
+          throw new Error(`HN Algolia item ${story.objectID}: HTTP ${itemRes.status}`);
+        }
+        const storyItem = await itemRes.json();
+        const comments = storyItem.children ?? [];
+        const jobs = [];
+        for (const comment of comments.slice(0, limit)) {
+          const job = parseComment(comment);
+          if (job) jobs.push(job);
+        }
+        return jobs;
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/feeds/index.ts
+async function aggregate(opts) {
+  const ghSlugs = opts?.slugs?.["greenhouse"] ?? DEFAULT_GREENHOUSE_SLUGS;
+  const ashbySlugs = opts?.slugs?.["ashby"] ?? DEFAULT_ASHBY_SLUGS;
+  const limit = opts?.limit ?? 150;
+  const settled = await Promise.allSettled([
+    greenhouse.fetch({ slugs: ghSlugs, limit }),
+    ashby.fetch({ slugs: ashbySlugs, limit }),
+    himalayas.fetch({ limit }),
+    wwr.fetch({ limit }),
+    hn.fetch({ limit })
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const jobs = [];
+  const sourceNames = ["greenhouse", "ashby", "himalayas", "wwr", "hn"];
+  for (let i = 0; i < settled.length; i++) {
+    const result = settled[i];
+    if (result.status === "rejected") {
+      console.warn(`[feeds] ${sourceNames[i]} failed:`, result.reason);
+      continue;
+    }
+    for (const job of result.value) {
+      if (!seen.has(job.id)) {
+        seen.add(job.id);
+        jobs.push(job);
+      }
+    }
+  }
+  return jobs;
+}
+var FEEDS, DEFAULT_GREENHOUSE_SLUGS, DEFAULT_ASHBY_SLUGS;
+var init_feeds = __esm({
+  "../../packages/core/src/feeds/index.ts"() {
+    "use strict";
+    init_greenhouse();
+    init_ashby();
+    init_himalayas();
+    init_wwr();
+    init_hn();
+    FEEDS = [greenhouse, ashby, himalayas, wwr, hn];
+    DEFAULT_GREENHOUSE_SLUGS = [
+      "stripe",
+      "linear",
+      "vercel",
+      "ramp",
+      "notion",
+      "airbnb",
+      "anthropic",
+      "figma",
+      "discord",
+      "brex",
+      "mercury",
+      "retool",
+      "vanta",
+      "plaid",
+      "gusto",
+      "scale",
+      "databricks",
+      "coinbase",
+      "robinhood",
+      "doordash"
+    ];
+    DEFAULT_ASHBY_SLUGS = [
+      "ramp",
+      "notion",
+      "linear",
+      "vercel",
+      "replit",
+      "posthog"
+    ];
+  }
+});
+
+// ../../packages/core/src/coastal.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+function resolveDataPath() {
+  try {
+    const dir = fileURLToPath(new URL("../../../data", import.meta.url));
+    return join(dir, "coastal-roles.json");
+  } catch {
+    return join(process.cwd(), "data", "coastal-roles.json");
+  }
+}
+function loadCoastalRoles() {
+  const filePath = resolveDataPath();
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      console.warn("[coastal] coastal-roles.json is not an array \u2014 skipping");
+      return [];
+    }
+    const valid = [];
+    for (const entry of parsed) {
+      if (typeof entry === "object" && entry !== null && typeof entry.id === "string" && entry.applyMode === "buyer-lead" && entry.buyer === "coastal") {
+        valid.push(entry);
+      } else {
+        console.warn("[coastal] Skipping malformed role entry:", entry);
+      }
+    }
+    return valid;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      console.warn(`[coastal] data/coastal-roles.json not found at ${filePath} \u2014 no Coastal roles loaded`);
+    } else {
+      console.warn("[coastal] Failed to load coastal-roles.json:", err);
+    }
+    return [];
+  }
+}
+var COASTAL_BUYER;
+var init_coastal = __esm({
+  "../../packages/core/src/coastal.ts"() {
+    "use strict";
+    COASTAL_BUYER = {
+      id: "coastal",
+      legalName: "Coastal Recruiting LLC",
+      matchCriteria: {
+        roleTypes: ["full_time"]
+      }
+    };
+  }
+});
+
+// ../../packages/core/src/indexer.ts
+async function buildIndex(opts) {
+  const includeCoastal = opts?.includeCoastal ?? true;
+  const publicJobs = await aggregate(opts);
+  const allJobs = [...publicJobs];
+  if (includeCoastal) {
+    const coastalJobs = loadCoastalRoles();
+    const seen = new Set(publicJobs.map((j) => j.id));
+    for (const job of coastalJobs) {
+      if (!seen.has(job.id)) {
+        seen.add(job.id);
+        allJobs.push(job);
+      }
+    }
+  }
+  const jobs = allJobs.map(({ raw: _raw, ...rest }) => rest);
+  return {
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    jobs
+  };
+}
+var init_indexer = __esm({
+  "../../packages/core/src/indexer.ts"() {
+    "use strict";
+    init_feeds();
+    init_coastal();
+  }
+});
+
+// ../../packages/core/src/github.ts
+function ghHeaders(token) {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return headers;
+}
+async function ghFetch(path, token) {
+  const url = `https://api.github.com${path}`;
+  const res = await fetch(url, { headers: ghHeaders(token) });
+  if (!res.ok) {
+    throw new Error(`GitHub API ${path}: HTTP ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function fetchGitHubProfile(login, token) {
+  const user = await ghFetch(`/users/${login}`, token);
+  let repos = [];
+  try {
+    repos = await ghFetch(
+      `/users/${login}/repos?sort=pushed&per_page=100`,
+      token
+    );
+  } catch (err) {
+    console.warn(`[github] ${login}: repos fetch failed, continuing \u2014`, err);
+  }
+  const langCount = {};
+  for (const repo of repos) {
+    if (repo.fork) continue;
+    if (repo.language) {
+      langCount[repo.language.toLowerCase()] = (langCount[repo.language.toLowerCase()] ?? 0) + 1;
+    }
+  }
+  const topLanguages = Object.entries(langCount).sort(([, a], [, b]) => b - a).slice(0, 10).map(([lang]) => lang);
+  const topicSet = /* @__PURE__ */ new Set();
+  for (const repo of repos) {
+    if (repo.fork) continue;
+    for (const t of repo.topics ?? []) topicSet.add(t.toLowerCase());
+  }
+  const topics = Array.from(topicSet).slice(0, 30);
+  let recentPRorgs;
+  try {
+    const q = encodeURIComponent(
+      `type:pr is:merged author:${login} sort:updated`
+    );
+    const result = await ghFetch(
+      `/search/issues?q=${q}&per_page=30`,
+      token
+    );
+    const orgs = /* @__PURE__ */ new Set();
+    for (const item of result.items ?? []) {
+      const orgLogin = item.repository?.owner?.login;
+      if (orgLogin && orgLogin !== login) orgs.add(orgLogin);
+    }
+    if (orgs.size > 0) recentPRorgs = Array.from(orgs);
+  } catch {
+  }
+  return {
+    login: user.login,
+    name: user.name ?? void 0,
+    publicEmail: user.email ?? void 0,
+    avatarUrl: user.avatar_url,
+    accountCreatedAt: user.created_at,
+    publicRepos: user.public_repos,
+    followers: user.followers,
+    topLanguages,
+    topics,
+    recentPRorgs
+  };
+}
+function inferSeniority2(p) {
+  const ageMs = Date.now() - new Date(p.accountCreatedAt).getTime();
+  const ageYears = ageMs / (1e3 * 60 * 60 * 24 * 365.25);
+  if (ageYears >= 9 && (p.publicRepos >= 40 || p.followers >= 500)) return "staff";
+  if (ageYears >= 5 && (p.publicRepos >= 20 || p.followers >= 100)) return "senior";
+  if (ageYears >= 2 && p.publicRepos >= 5) return "mid";
+  if (ageYears < 2 || p.publicRepos < 5) return "junior";
+  return void 0;
+}
+function githubToFingerprint(p) {
+  const rawTokens = [
+    ...p.topLanguages,
+    ...p.topics
+    // recentPRorgs intentionally excluded — org names are not skill tags
+  ];
+  const skillTags = normalize(rawTokens);
+  const seniorityBand = inferSeniority2(p);
+  return { skillTags, seniorityBand };
+}
+var init_github = __esm({
+  "../../packages/core/src/github.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  COASTAL_BUYER: () => COASTAL_BUYER,
+  DEFAULT_ASHBY_SLUGS: () => DEFAULT_ASHBY_SLUGS,
+  DEFAULT_GREENHOUSE_SLUGS: () => DEFAULT_GREENHOUSE_SLUGS,
+  FEEDS: () => FEEDS,
+  SYNONYMS: () => SYNONYMS,
+  VOCABULARY: () => VOCABULARY,
+  aggregate: () => aggregate,
+  ashby: () => ashby,
+  buildIndex: () => buildIndex,
+  buildReason: () => buildReason,
+  fetchGitHubProfile: () => fetchGitHubProfile,
+  githubToFingerprint: () => githubToFingerprint,
+  greenhouse: () => greenhouse,
+  himalayas: () => himalayas,
+  hn: () => hn,
+  loadCoastalRoles: () => loadCoastalRoles,
+  match: () => match,
+  matchOne: () => matchOne,
+  normalize: () => normalize,
+  wwr: () => wwr
+});
+var init_src = __esm({
+  "../../packages/core/src/index.ts"() {
+    "use strict";
+    init_types();
+    init_vocabulary();
+    init_matcher();
+    init_feeds();
+    init_indexer();
+    init_coastal();
+    init_github();
+  }
+});
+
+// src/profile.ts
+var profile_exports = {};
+__export(profile_exports, {
+  accumulateGitHubTags: () => accumulateGitHubTags,
+  accumulateSession: () => accumulateSession,
+  accumulateTags: () => accumulateTags,
+  addSavedJob: () => addSavedJob,
+  deleteProfile: () => deleteProfile,
+  listSavedJobs: () => listSavedJobs,
+  profileToFingerprint: () => profileToFingerprint,
+  readProfile: () => readProfile,
+  removeSavedJob: () => removeSavedJob,
+  writeProfile: () => writeProfile
+});
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes
+} from "crypto";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  mkdirSync,
+  existsSync
+} from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+async function loadKey() {
+  try {
+    const kt = await import("keytar");
+    const stored = await kt.getPassword("terminalhire", "profile-key");
+    if (stored) {
+      return Buffer.from(stored, "hex");
+    }
+    const key2 = randomBytes(KEY_BYTES);
+    await kt.setPassword("terminalhire", "profile-key", key2.toString("hex"));
+    return key2;
+  } catch {
+  }
+  mkdirSync(TERMINALHIRE_DIR, { recursive: true });
+  if (existsSync(KEY_FILE)) {
+    return Buffer.from(readFileSync2(KEY_FILE, "utf8").trim(), "hex");
+  }
+  const key = randomBytes(KEY_BYTES);
+  writeFileSync(KEY_FILE, key.toString("hex"), { mode: 384, encoding: "utf8" });
+  return key;
+}
+function encrypt(plaintext, key) {
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv(ALGO, key, iv);
+  const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("hex"),
+    tag: tag.toString("hex"),
+    ciphertext: ct.toString("hex")
+  };
+}
+function decrypt(blob, key) {
+  const decipher = createDecipheriv(
+    ALGO,
+    key,
+    Buffer.from(blob.iv, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+  const plain = Buffer.concat([
+    decipher.update(Buffer.from(blob.ciphertext, "hex")),
+    decipher.final()
+  ]);
+  return plain.toString("utf8");
+}
+function blankProfile() {
+  return {
+    version: 3,
+    skillTags: [],
+    tagWeights: {},
+    hasEmployerSessions: false,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function recencyDecay(lastSeen) {
+  const ageMs = Date.now() - new Date(lastSeen).getTime();
+  return Math.pow(0.5, ageMs / DECAY_HALF_LIFE_MS);
+}
+function tagScore(w) {
+  return w.count * recencyDecay(w.lastSeen);
+}
+function deriveSkillTags(tagWeights) {
+  return Object.entries(tagWeights).filter(([, w]) => w.count >= 1).sort(([, a], [, b]) => tagScore(b) - tagScore(a)).map(([tag]) => tag);
+}
+function migrateTagWeights(profile) {
+  if (!profile.tagWeights) {
+    profile.tagWeights = {};
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const tag of profile.skillTags) {
+    if (!profile.tagWeights[tag]) {
+      profile.tagWeights[tag] = { count: 1, firstSeen: now, lastSeen: now, sessions: 1 };
+    }
+  }
+}
+async function readProfile() {
+  if (!existsSync(PROFILE_FILE)) return blankProfile();
+  try {
+    const key = await loadKey();
+    const raw = readFileSync2(PROFILE_FILE, "utf8");
+    const blob = JSON.parse(raw);
+    const plaintext = decrypt(blob, key);
+    const parsed = JSON.parse(plaintext);
+    migrateTagWeights(parsed);
+    return parsed;
+  } catch {
+    return blankProfile();
+  }
+}
+async function writeProfile(profile) {
+  mkdirSync(TERMINALHIRE_DIR, { recursive: true });
+  const key = await loadKey();
+  profile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  profile.skillTags = deriveSkillTags(profile.tagWeights);
+  const blob = encrypt(JSON.stringify(profile), key);
+  writeFileSync(PROFILE_FILE, JSON.stringify(blob, null, 2), { encoding: "utf8" });
+}
+function accumulateSession(profile, tags, isEmployerContext2, inferredSeniority) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let filtered = normalize(tags);
+  if (isEmployerContext2) {
+    filtered = filtered.filter((t) => LANGUAGE_TAGS.has(t));
+    profile.hasEmployerSessions = true;
+  }
+  for (const tag of filtered) {
+    const existing = profile.tagWeights[tag];
+    if (existing) {
+      existing.count += 1;
+      existing.sessions += 1;
+      existing.lastSeen = now;
+    } else {
+      profile.tagWeights[tag] = { count: 1, firstSeen: now, lastSeen: now, sessions: 1 };
+    }
+  }
+  if (inferredSeniority && !isEmployerContext2) {
+    profile.seniority = inferredSeniority;
+  }
+}
+async function accumulateTags(rawTokens, isEmployerContext2, inferredSeniority) {
+  const profile = await readProfile();
+  accumulateSession(profile, rawTokens, isEmployerContext2, inferredSeniority);
+  await writeProfile(profile);
+}
+function accumulateGitHubTags(profile, tags) {
+  accumulateSession(
+    profile,
+    tags,
+    /* isEmployerContext */
+    false
+  );
+}
+async function listSavedJobs() {
+  const profile = await readProfile();
+  return profile.savedJobs ?? [];
+}
+async function addSavedJob(job) {
+  const profile = await readProfile();
+  const existing = profile.savedJobs ?? [];
+  const filtered = existing.filter((j) => j.id !== job.id);
+  profile.savedJobs = [...filtered, { ...job, savedAt: (/* @__PURE__ */ new Date()).toISOString() }];
+  await writeProfile(profile);
+}
+async function removeSavedJob(id) {
+  const profile = await readProfile();
+  const existing = profile.savedJobs ?? [];
+  const filtered = existing.filter((j) => j.id !== id);
+  if (filtered.length === existing.length) return false;
+  profile.savedJobs = filtered;
+  await writeProfile(profile);
+  return true;
+}
+async function deleteProfile() {
+  const { rmSync } = await import("fs");
+  try {
+    rmSync(PROFILE_FILE);
+  } catch {
+  }
+  try {
+    rmSync(KEY_FILE);
+  } catch {
+  }
+}
+function profileToFingerprint(profile) {
+  const rankedTags = Object.entries(profile.tagWeights).map(([tag, w]) => ({ tag, score: tagScore(w) })).filter(({ score }) => score >= MIN_FINGERPRINT_SCORE).sort((a, b) => b.score - a.score).map(({ tag }) => tag);
+  const skillTags = rankedTags.length > 0 ? rankedTags : profile.skillTags;
+  return {
+    skillTags,
+    seniorityBand: profile.seniority,
+    prefs: {
+      roleTypes: profile.roleTypes,
+      remoteOnly: profile.remoteOnly,
+      compFloorUsd: profile.compFloorUsd
+    }
+  };
+}
+var TERMINALHIRE_DIR, PROFILE_FILE, KEY_FILE, ALGO, KEY_BYTES, IV_BYTES, DECAY_HALF_LIFE_MS, LANGUAGE_TAGS, MIN_FINGERPRINT_SCORE;
+var init_profile = __esm({
+  "src/profile.ts"() {
+    "use strict";
+    init_src();
+    TERMINALHIRE_DIR = join2(homedir(), ".terminalhire");
+    PROFILE_FILE = join2(TERMINALHIRE_DIR, "profile.enc");
+    KEY_FILE = join2(TERMINALHIRE_DIR, "key");
+    ALGO = "aes-256-gcm";
+    KEY_BYTES = 32;
+    IV_BYTES = 12;
+    DECAY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+    LANGUAGE_TAGS = /* @__PURE__ */ new Set([
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "java",
+      "ruby",
+      "elixir",
+      "scala",
+      "kotlin",
+      "swift",
+      "cpp",
+      "csharp",
+      "php",
+      "haskell",
+      "clojure",
+      "r"
+    ]);
+    MIN_FINGERPRINT_SCORE = 0.05;
+  }
+});
+
+// bin/spinner.js
+var spinner_exports = {};
+__export(spinner_exports, {
+  SPINNER_DEFAULTS: () => SPINNER_DEFAULTS,
+  applySpinnerTips: () => applySpinnerTips,
+  applySpinnerVerbs: () => applySpinnerVerbs,
+  buildContextVerbs: () => buildContextVerbs,
+  buildSpinnerPool: () => buildSpinnerPool,
+  buildTips: () => buildTips,
+  clearSpinnerTips: () => clearSpinnerTips,
+  clearSpinnerVerbs: () => clearSpinnerVerbs,
+  ctaVerb: () => ctaVerb,
+  formatVerbs: () => formatVerbs,
+  rankBySessionTags: () => rankBySessionTags,
+  readSpinnerConfig: () => readSpinnerConfig
+});
+import {
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  renameSync
+} from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir2 } from "os";
+function readJson(path, fallback) {
+  try {
+    return existsSync2(path) ? JSON.parse(readFileSync3(path, "utf8")) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function atomicWriteJson(path, obj) {
+  mkdirSync2(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync2(tmp, JSON.stringify(obj, null, 2) + "\n", "utf8");
+  renameSync(tmp, path);
+}
+function titleCase(s) {
+  return String(s || "").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function readSpinnerConfig() {
+  const cfg = readJson(CONFIG_FILE, {});
+  const spinner = cfg && typeof cfg.spinner === "object" ? cfg.spinner : {};
+  const merged = { ...SPINNER_DEFAULTS, ...spinner };
+  if (merged.mode !== "append" && merged.mode !== "replace") merged.mode = SPINNER_DEFAULTS.mode;
+  merged.max = Math.max(1, Math.min(12, Number(merged.max) || SPINNER_DEFAULTS.max));
+  merged.enabled = merged.enabled === true;
+  if (!["always", "sometimes", "rare"].includes(merged.frequency)) {
+    merged.frequency = SPINNER_DEFAULTS.frequency;
+  }
+  return merged;
+}
+function ctaVerb() {
+  return "\u2605 jobs that fit you \xB7 run: terminalhire jobs";
+}
+function formatVerbs(topMatches, max = 6) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of Array.isArray(topMatches) ? topMatches : []) {
+    if (!m || !m.title || !m.company) continue;
+    let title = String(m.title).trim().replace(/\s+/g, " ");
+    if (title.length > 32) title = title.slice(0, 31).trimEnd() + "\u2026";
+    const company = titleCase(String(m.company).trim().replace(/\s+/g, " "));
+    const pct = Math.max(1, Math.min(99, Math.round((Number(m.score) || 0) * 100)));
+    const key = `${title.toLowerCase()}@${company.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const intro = VERB_INTROS[out.length % VERB_INTROS.length];
+    out.push(`${intro} ${title} @ ${company} \xB7 ${pct}% match`);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function rankBySessionTags(topMatches, sessionTags) {
+  const tags = Array.isArray(sessionTags) ? sessionTags.filter(Boolean) : [];
+  if (tags.length === 0 || !Array.isArray(topMatches)) return topMatches;
+  const normalized = tags.map((t) => String(t).toLowerCase().trim());
+  return topMatches.map((m, originalIndex) => {
+    const haystack = `${String(m.title || "").toLowerCase()} ${String(m.company || "").toLowerCase()}`;
+    const hits = normalized.reduce((n, tag) => n + (haystack.includes(tag) ? 1 : 0), 0);
+    return { m, hits, originalIndex };
+  }).sort((a, b) => b.hits - a.hits || a.originalIndex - b.originalIndex).map(({ m }) => m);
+}
+function verbCountForFrequency(frequency, max) {
+  switch (frequency) {
+    case "always":
+      return max;
+    case "rare":
+      return 1;
+    case "sometimes":
+    default:
+      return 2;
+  }
+}
+function buildContextVerbs(topMatches, sessionTags) {
+  const sess = (Array.isArray(sessionTags) ? sessionTags : []).map((t) => String(t).toLowerCase().trim()).filter(Boolean);
+  const roleTags = /* @__PURE__ */ new Set();
+  for (const m of Array.isArray(topMatches) ? topMatches : []) {
+    const mt = m && Array.isArray(m.matchedTags) ? m.matchedTags : [];
+    for (const t of mt) roleTags.add(String(t).toLowerCase().trim());
+  }
+  const overlap = [];
+  for (const t of sess) {
+    if (roleTags.has(t) && !overlap.includes(t)) overlap.push(t);
+  }
+  if (overlap.length >= 2) {
+    const a = titleCase(overlap[0]);
+    const b = titleCase(overlap[1]);
+    return [`\u2726 Fits your ${a} + ${b} work`, `\u2726 A role matching what you're building`];
+  }
+  if (overlap.length === 1) {
+    const a = titleCase(overlap[0]);
+    return [`\u2726 A role matching your ${a} work`, `\u2726 Your ${a} work \u2014 link in the tip below`];
+  }
+  return [`\u2726 A role that fits your work`, `\u2726 Job match for you \u2014 link in the tip below`];
+}
+function buildSpinnerPool(topMatches, max = 6, opts = {}) {
+  const { sessionTags, frequency = "always" } = opts;
+  const ranked = rankBySessionTags(topMatches, sessionTags);
+  if (!Array.isArray(ranked) || ranked.length === 0) return [];
+  const headers = buildContextVerbs(ranked, sessionTags);
+  const cap = Math.max(1, verbCountForFrequency(frequency, headers.length));
+  return [...headers.slice(0, cap), ctaVerb()];
+}
+function readState() {
+  return readJson(SPINNER_STATE_FILE, { verbs: [], mode: "replace" });
+}
+function applySpinnerVerbs(ourVerbs, mode = "replace") {
+  const verbs = (Array.isArray(ourVerbs) ? ourVerbs : []).filter(Boolean);
+  if (verbs.length === 0) return clearSpinnerVerbs();
+  const settings = readJson(CLAUDE_SETTINGS, {}) || {};
+  const existing = settings.spinnerVerbs && typeof settings.spinnerVerbs === "object" ? settings.spinnerVerbs : null;
+  const prevOurs = new Set(readState().verbs || []);
+  const userVerbs = existing && Array.isArray(existing.verbs) ? existing.verbs.filter((v) => !prevOurs.has(v)) : [];
+  const newVerbs = [...verbs, ...userVerbs];
+  settings.spinnerVerbs = { mode: mode === "append" ? "append" : "replace", verbs: newVerbs };
+  atomicWriteJson(CLAUDE_SETTINGS, settings);
+  const st = readState();
+  atomicWriteJson(SPINNER_STATE_FILE, { ...st, verbs, mode, ts: Date.now() });
+  return { applied: verbs.length, total: newVerbs.length };
+}
+function clearSpinnerVerbs() {
+  const settings = readJson(CLAUDE_SETTINGS, null);
+  const prevOurs = new Set(readState().verbs || []);
+  let keptUserVerbs = 0;
+  if (settings && settings.spinnerVerbs && Array.isArray(settings.spinnerVerbs.verbs)) {
+    const userVerbs = settings.spinnerVerbs.verbs.filter((v) => !prevOurs.has(v));
+    keptUserVerbs = userVerbs.length;
+    if (userVerbs.length > 0) {
+      settings.spinnerVerbs = {
+        mode: settings.spinnerVerbs.mode === "append" ? "append" : "replace",
+        verbs: userVerbs
+      };
+    } else {
+      delete settings.spinnerVerbs;
+    }
+    atomicWriteJson(CLAUDE_SETTINGS, settings);
+  }
+  try {
+    const st = readState();
+    atomicWriteJson(SPINNER_STATE_FILE, { ...st, verbs: [], mode: st.mode || "replace", ts: Date.now() });
+  } catch {
+  }
+  return { cleared: true, keptUserVerbs };
+}
+function buildTips(topMatches, baseUrl, max = 8) {
+  const base = String(baseUrl || "https://terminalhire.com").replace(/\/+$/, "");
+  const out = [];
+  const seenRole = /* @__PURE__ */ new Set();
+  const perCompany = /* @__PURE__ */ new Map();
+  const COMPANY_CAP = 2;
+  for (const m of Array.isArray(topMatches) ? topMatches : []) {
+    if (!m || !m.title || !m.company || !m.id) continue;
+    const idx = String(m.id).indexOf(":");
+    if (idx <= 0) continue;
+    const source = String(m.id).slice(0, idx);
+    const ext = String(m.id).slice(idx + 1);
+    if (!source || !ext) continue;
+    const companyRaw = String(m.company).trim().replace(/\s+/g, " ");
+    const titleRaw = String(m.title).trim().replace(/\s+/g, " ");
+    const roleKey = `${titleRaw.toLowerCase()}@${companyRaw.toLowerCase()}`;
+    const coKey = companyRaw.toLowerCase();
+    if (seenRole.has(roleKey)) continue;
+    if ((perCompany.get(coKey) || 0) >= COMPANY_CAP) continue;
+    seenRole.add(roleKey);
+    perCompany.set(coKey, (perCompany.get(coKey) || 0) + 1);
+    let title = titleRaw;
+    if (title.length > 34) title = title.slice(0, 33).trimEnd() + "\u2026";
+    const company = titleCase(companyRaw);
+    const pct = Math.max(1, Math.min(99, Math.round((Number(m.score) || 0) * 100)));
+    const token = Buffer.from(String(m.id)).toString("base64url");
+    const url = `${base}/j/${token}`;
+    out.push(`\u2197 ${title} @ ${company} \xB7 ${pct}% \u2014 ${url}`);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function applySpinnerTips(ourTips) {
+  const tips = (Array.isArray(ourTips) ? ourTips : []).filter(Boolean);
+  if (tips.length === 0) return clearSpinnerTips();
+  const settings = readJson(CLAUDE_SETTINGS, {}) || {};
+  const existing = settings.spinnerTipsOverride && Array.isArray(settings.spinnerTipsOverride.tips) ? settings.spinnerTipsOverride.tips : [];
+  const prevOurs = new Set(readState().tips || []);
+  const userTips = existing.filter((t) => !prevOurs.has(t));
+  settings.spinnerTipsEnabled = true;
+  settings.spinnerTipsOverride = { excludeDefault: true, tips: [...tips, ...userTips] };
+  atomicWriteJson(CLAUDE_SETTINGS, settings);
+  const st = readState();
+  atomicWriteJson(SPINNER_STATE_FILE, { ...st, tips, ts: Date.now() });
+  return { applied: tips.length };
+}
+function clearSpinnerTips() {
+  const settings = readJson(CLAUDE_SETTINGS, null);
+  const prevOurs = new Set(readState().tips || []);
+  if (settings && settings.spinnerTipsOverride && Array.isArray(settings.spinnerTipsOverride.tips)) {
+    const userTips = settings.spinnerTipsOverride.tips.filter((t) => !prevOurs.has(t));
+    if (userTips.length > 0) {
+      settings.spinnerTipsOverride = {
+        excludeDefault: settings.spinnerTipsOverride.excludeDefault === true,
+        tips: userTips
+      };
+    } else {
+      delete settings.spinnerTipsOverride;
+      delete settings.spinnerTipsEnabled;
+    }
+    atomicWriteJson(CLAUDE_SETTINGS, settings);
+  }
+  try {
+    const st = readState();
+    atomicWriteJson(SPINNER_STATE_FILE, { ...st, tips: [], ts: Date.now() });
+  } catch {
+  }
+  return { cleared: true };
+}
+var TH_DIR, CLAUDE_SETTINGS, CONFIG_FILE, SPINNER_STATE_FILE, SPINNER_DEFAULTS, VERB_INTROS;
+var init_spinner = __esm({
+  "bin/spinner.js"() {
+    "use strict";
+    TH_DIR = process.env["TERMINALHIRE_DIR"] || join3(homedir2(), ".terminalhire");
+    CLAUDE_SETTINGS = process.env["TERMINALHIRE_CLAUDE_SETTINGS"] || join3(homedir2(), ".claude", "settings.json");
+    CONFIG_FILE = join3(TH_DIR, "config.json");
+    SPINNER_STATE_FILE = join3(TH_DIR, "spinner-state.json");
+    SPINNER_DEFAULTS = { enabled: false, mode: "append", max: 6, frequency: "sometimes" };
+    VERB_INTROS = ["Matched:", "You\u2019d fit:", "Worth a look:", "On your radar:", "Fits your stack:"];
+  }
+});
+
+// src/signal.ts
+var signal_exports = {};
+__export(signal_exports, {
+  extractFingerprint: () => extractFingerprint
+});
+import { readFileSync as readFileSync4, readdirSync } from "fs";
+import { execSync } from "child_process";
+import { join as join4 } from "path";
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { timeout: 2e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+function isEmployerContext(cwd) {
+  const remote = safeExec('git -C "' + cwd + '" remote get-url origin 2>/dev/null');
+  if (remote) {
+    try {
+      const sshMatch = remote.match(/^git@([^:]+):/);
+      const httpsMatch = remote.match(/^https?:\/\/([^/]+)/);
+      const host = (sshMatch?.[1] ?? httpsMatch?.[1] ?? "").toLowerCase();
+      if (host && !PERSONAL_GIT_HOSTS.has(host)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  const email = safeExec('git -C "' + cwd + '" config user.email 2>/dev/null');
+  if (email) {
+    const domain = email.split("@")[1]?.toLowerCase() ?? "";
+    if (domain && !PERSONAL_EMAIL_DOMAINS.has(domain)) {
+      return true;
+    }
+  }
+  return false;
+}
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync4(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readFileSafe(path) {
+  try {
+    return readFileSync4(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function tokensFromPackageJson(cwd) {
+  const pkg = readJsonSafe(join4(cwd, "package.json"));
+  if (!pkg || typeof pkg !== "object") return [];
+  const p = pkg;
+  const deps = {
+    ...typeof p["dependencies"] === "object" ? p["dependencies"] : {},
+    ...typeof p["devDependencies"] === "object" ? p["devDependencies"] : {}
+  };
+  return Object.keys(deps);
+}
+function tokensFromRequirementsTxt(cwd) {
+  const content = readFileSafe(join4(cwd, "requirements.txt"));
+  if (!content) return [];
+  return content.split("\n").map((l) => l.trim().split(/[>=<!\[;]/)[0].trim().toLowerCase()).filter(Boolean);
+}
+function tokensFromGoMod(cwd) {
+  const content = readFileSafe(join4(cwd, "go.mod"));
+  if (!content) return ["go"];
+  const requires = Array.from(content.matchAll(/^\s+([^\s]+)\s+v/gm)).map((m) => m[1].split("/").pop() ?? "").filter(Boolean);
+  return ["go", ...requires];
+}
+function tokensFromCargoToml(cwd) {
+  const content = readFileSafe(join4(cwd, "Cargo.toml"));
+  if (!content) return [];
+  const deps = Array.from(content.matchAll(/^([a-zA-Z0-9_-]+)\s*=/gm)).map((m) => m[1].toLowerCase());
+  return ["rust", ...deps];
+}
+function tokensFromFileExtensions(cwd) {
+  const tokens = [];
+  const scanDirs = [cwd];
+  try {
+    const srcDir = join4(cwd, "src");
+    readdirSync(srcDir);
+    scanDirs.push(srcDir);
+  } catch {
+  }
+  for (const dir of scanDirs) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const e of entries) {
+        if (!e.isFile()) continue;
+        const dotIdx = e.name.lastIndexOf(".");
+        if (dotIdx === -1) continue;
+        const ext = e.name.slice(dotIdx).toLowerCase();
+        const tag = EXT_MAP[ext];
+        if (tag) tokens.push(tag);
+      }
+    } catch {
+    }
+  }
+  return tokens;
+}
+function inferSeniority3(rawTokens) {
+  const seniorSignals = /* @__PURE__ */ new Set([
+    "kubernetes",
+    "terraform",
+    "pulumi",
+    "kafka",
+    "spark",
+    "airflow",
+    "dbt",
+    "opentelemetry",
+    "prometheus",
+    "grafana",
+    "microservices",
+    "api-design",
+    "security",
+    "oauth",
+    "payments"
+  ]);
+  const midSignals = /* @__PURE__ */ new Set([
+    "docker",
+    "ci-cd",
+    "github-actions",
+    "testing",
+    "postgresql",
+    "redis",
+    "graphql",
+    "trpc"
+  ]);
+  const normalized = new Set(normalize(rawTokens));
+  const seniorHits = [...normalized].filter((t) => seniorSignals.has(t)).length;
+  const midHits = [...normalized].filter((t) => midSignals.has(t)).length;
+  if (seniorHits >= 2) return "senior";
+  if (seniorHits >= 1 || midHits >= 2) return "mid";
+  return void 0;
+}
+function extractFingerprint(cwd) {
+  const employer = isEmployerContext(cwd);
+  const rawTokens = [
+    ...tokensFromPackageJson(cwd),
+    ...tokensFromRequirementsTxt(cwd),
+    ...tokensFromGoMod(cwd),
+    ...tokensFromCargoToml(cwd),
+    ...tokensFromFileExtensions(cwd)
+  ];
+  let skillTags = normalize(rawTokens);
+  if (employer) {
+    skillTags = skillTags.filter((t) => LANGUAGE_TAGS2.has(t));
+  }
+  const seniorityBand = employer ? void 0 : inferSeniority3(rawTokens);
+  return {
+    skillTags,
+    seniorityBand,
+    employerContext: employer
+  };
+}
+var LANGUAGE_TAGS2, EXT_MAP, PERSONAL_GIT_HOSTS, PERSONAL_EMAIL_DOMAINS;
+var init_signal = __esm({
+  "src/signal.ts"() {
+    "use strict";
+    init_src();
+    LANGUAGE_TAGS2 = /* @__PURE__ */ new Set([
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "java",
+      "ruby",
+      "elixir",
+      "scala",
+      "kotlin",
+      "swift",
+      "cpp",
+      "csharp",
+      "php",
+      "haskell",
+      "clojure",
+      "r"
+    ]);
+    EXT_MAP = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".js": "javascript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".jsx": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".rb": "ruby",
+      ".ex": "elixir",
+      ".exs": "elixir",
+      ".scala": "scala",
+      ".kt": "kotlin",
+      ".swift": "swift",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".hpp": "cpp",
+      ".cs": "csharp",
+      ".php": "php",
+      ".hs": "haskell",
+      ".clj": "clojure",
+      ".cljs": "clojure",
+      ".r": "r",
+      ".vue": "vue",
+      ".svelte": "svelte"
+    };
+    PERSONAL_GIT_HOSTS = /* @__PURE__ */ new Set([
+      "github.com",
+      "gitlab.com",
+      "bitbucket.org",
+      "codeberg.org",
+      "sr.ht"
+    ]);
+    PERSONAL_EMAIL_DOMAINS = /* @__PURE__ */ new Set([
+      "gmail.com",
+      "googlemail.com",
+      "yahoo.com",
+      "outlook.com",
+      "hotmail.com",
+      "icloud.com",
+      "me.com",
+      "mac.com",
+      "proton.me",
+      "protonmail.com",
+      "fastmail.com",
+      "hey.com",
+      "duck.com"
+    ]);
+  }
+});
+
+// bin/jpi-refresh.js
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname = fileURLToPath2(new URL(".", import.meta.url));
+var TERMINALHIRE_DIR2 = join5(homedir3(), ".terminalhire");
+var INDEX_CACHE_FILE = join5(TERMINALHIRE_DIR2, "index-cache.json");
+var API_URL = process.env["TERMINALHIRE_API_URL"] ?? process.env["JPI_API_URL"] ?? "https://terminalhire.com";
+async function run() {
+  try {
+    let index;
+    try {
+      const res = await fetch(`${API_URL}/api/index`, {
+        signal: AbortSignal.timeout(15e3),
+        headers: { "Accept": "application/json" }
+      });
+      if (!res.ok) {
+        process.stderr.write(`terminalhire refresh: index fetch failed (HTTP ${res.status})
+`);
+        process.exit(1);
+      }
+      index = await res.json();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`terminalhire refresh: fetch error \u2014 ${msg}
+`);
+      process.exit(1);
+    }
+    const jobs = index?.jobs ?? [];
+    let matchCount = 0;
+    let topMatches = [];
+    try {
+      const { readProfile: readProfile2, profileToFingerprint: profileToFingerprint2 } = await Promise.resolve().then(() => (init_profile(), profile_exports));
+      const { match: match2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const profile = await readProfile2();
+      if (profile.skillTags.length > 0 && jobs.length > 0) {
+        const fp = profileToFingerprint2(profile);
+        const results = match2(fp, jobs, jobs.length);
+        matchCount = results.length;
+        topMatches = results.slice(0, 25).map((r) => ({
+          id: r.job.id,
+          title: r.job.title,
+          company: r.job.company,
+          score: r.score,
+          remote: r.job.remote,
+          matchedTags: r.matchedTags
+        }));
+      }
+    } catch {
+    }
+    mkdirSync3(TERMINALHIRE_DIR2, { recursive: true });
+    const cacheEntry = {
+      ts: Date.now(),
+      index,
+      matchCount,
+      topMatches
+    };
+    writeFileSync3(INDEX_CACHE_FILE, JSON.stringify(cacheEntry), "utf8");
+    try {
+      const {
+        readSpinnerConfig: readSpinnerConfig2,
+        buildSpinnerPool: buildSpinnerPool2,
+        applySpinnerVerbs: applySpinnerVerbs2,
+        clearSpinnerVerbs: clearSpinnerVerbs2,
+        buildTips: buildTips2,
+        applySpinnerTips: applySpinnerTips2,
+        clearSpinnerTips: clearSpinnerTips2,
+        rankBySessionTags: rankBySessionTags2
+      } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
+      const sc = readSpinnerConfig2();
+      if (sc.enabled) {
+        let sessionTags;
+        try {
+          const { extractFingerprint: extractFingerprint2 } = await Promise.resolve().then(() => (init_signal(), signal_exports));
+          const fp = extractFingerprint2(process.cwd());
+          if (Array.isArray(fp.skillTags) && fp.skillTags.length > 0) {
+            sessionTags = fp.skillTags;
+          }
+        } catch {
+        }
+        const ranked = rankBySessionTags2(topMatches, sessionTags);
+        const verbs = buildSpinnerPool2(ranked, sc.max, { sessionTags, frequency: sc.frequency });
+        if (verbs.length > 0) applySpinnerVerbs2(verbs, sc.mode);
+        else clearSpinnerVerbs2();
+        const tips = buildTips2(ranked, API_URL, 8);
+        if (tips.length > 0) applySpinnerTips2(tips);
+        else clearSpinnerTips2();
+      } else {
+        clearSpinnerVerbs2();
+        clearSpinnerTips2();
+      }
+    } catch {
+    }
+    process.exit(0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`terminalhire refresh: unexpected error \u2014 ${msg}
+`);
+    process.exit(1);
+  }
+}
+export {
+  run
+};