terminalhire 0.1.0

package/dist/src/profile.js

@@ -0,0 +1,423 @@
+// src/profile.ts
+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";
+
+// ../../packages/core/src/vocabulary.ts
+var 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"
+];
+var 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"
+};
+var VOCAB_SET = new Set(VOCABULARY);
+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);
+}
+
+// ../../packages/core/src/coastal.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+
+// src/profile.ts
+var TERMINALHIRE_DIR = join2(homedir(), ".terminalhire");
+var PROFILE_FILE = join2(TERMINALHIRE_DIR, "profile.enc");
+var KEY_FILE = join2(TERMINALHIRE_DIR, "key");
+var ALGO = "aes-256-gcm";
+var KEY_BYTES = 32;
+var IV_BYTES = 12;
+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()
+  };
+}
+var DECAY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+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" });
+}
+var LANGUAGE_TAGS = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "ruby",
+  "elixir",
+  "scala",
+  "kotlin",
+  "swift",
+  "cpp",
+  "csharp",
+  "php",
+  "haskell",
+  "clojure",
+  "r"
+]);
+function accumulateSession(profile, tags, isEmployerContext, inferredSeniority) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let filtered = normalize(tags);
+  if (isEmployerContext) {
+    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 && !isEmployerContext) {
+    profile.seniority = inferredSeniority;
+  }
+}
+async function accumulateTags(rawTokens, isEmployerContext, inferredSeniority) {
+  const profile = await readProfile();
+  accumulateSession(profile, rawTokens, isEmployerContext, inferredSeniority);
+  await writeProfile(profile);
+}
+function accumulateGitHubTags(profile, tags) {
+  accumulateSession(
+    profile,
+    tags,
+    /* isEmployerContext */
+    false
+  );
+}
+async function deleteProfile() {
+  const { rmSync } = await import("fs");
+  try {
+    rmSync(PROFILE_FILE);
+  } catch {
+  }
+  try {
+    rmSync(KEY_FILE);
+  } catch {
+  }
+}
+var MIN_FINGERPRINT_SCORE = 0.05;
+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
+    }
+  };
+}
+export {
+  accumulateGitHubTags,
+  accumulateSession,
+  accumulateTags,
+  deleteProfile,
+  profileToFingerprint,
+  readProfile,
+  writeProfile
+};