terminalhire 0.1.0

package/dist/bin/jpi-learn.js

@@ -0,0 +1,815 @@
+#!/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
+var init_matcher = __esm({
+  "../../packages/core/src/matcher.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/core/src/feeds/greenhouse.ts
+var init_greenhouse = __esm({
+  "../../packages/core/src/feeds/greenhouse.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/feeds/ashby.ts
+var init_ashby = __esm({
+  "../../packages/core/src/feeds/ashby.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/feeds/himalayas.ts
+var init_himalayas = __esm({
+  "../../packages/core/src/feeds/himalayas.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/feeds/wwr.ts
+var init_wwr = __esm({
+  "../../packages/core/src/feeds/wwr.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/feeds/hn.ts
+var init_hn = __esm({
+  "../../packages/core/src/feeds/hn.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/feeds/index.ts
+var init_feeds = __esm({
+  "../../packages/core/src/feeds/index.ts"() {
+    "use strict";
+    init_greenhouse();
+    init_ashby();
+    init_himalayas();
+    init_wwr();
+    init_hn();
+  }
+});
+
+// ../../packages/core/src/coastal.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+var init_coastal = __esm({
+  "../../packages/core/src/coastal.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/core/src/indexer.ts
+var init_indexer = __esm({
+  "../../packages/core/src/indexer.ts"() {
+    "use strict";
+    init_feeds();
+    init_coastal();
+  }
+});
+
+// ../../packages/core/src/github.ts
+var init_github = __esm({
+  "../../packages/core/src/github.ts"() {
+    "use strict";
+    init_vocabulary();
+  }
+});
+
+// ../../packages/core/src/index.ts
+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/signal.ts
+var signal_exports = {};
+__export(signal_exports, {
+  extractFingerprint: () => extractFingerprint
+});
+import { readFileSync as readFileSync2, readdirSync } from "fs";
+import { execSync } from "child_process";
+import { join as join2 } 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(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readFileSafe(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function tokensFromPackageJson(cwd) {
+  const pkg = readJsonSafe(join2(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(join2(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(join2(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(join2(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 = join2(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 inferSeniority(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_TAGS.has(t));
+  }
+  const seniorityBand = employer ? void 0 : inferSeniority(rawTokens);
+  return {
+    skillTags,
+    seniorityBand,
+    employerContext: employer
+  };
+}
+var LANGUAGE_TAGS, EXT_MAP, PERSONAL_GIT_HOSTS, PERSONAL_EMAIL_DOMAINS;
+var init_signal = __esm({
+  "src/signal.ts"() {
+    "use strict";
+    init_src();
+    LANGUAGE_TAGS = /* @__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"
+    ]);
+  }
+});
+
+// src/profile.ts
+var profile_exports = {};
+__export(profile_exports, {
+  accumulateGitHubTags: () => accumulateGitHubTags,
+  accumulateSession: () => accumulateSession,
+  accumulateTags: () => accumulateTags,
+  deleteProfile: () => deleteProfile,
+  profileToFingerprint: () => profileToFingerprint,
+  readProfile: () => readProfile,
+  writeProfile: () => writeProfile
+});
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes
+} from "crypto";
+import {
+  readFileSync as readFileSync3,
+  writeFileSync,
+  mkdirSync,
+  existsSync
+} from "fs";
+import { join as join3 } 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(readFileSync3(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 = readFileSync3(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_TAGS2.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 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_TAGS2, MIN_FINGERPRINT_SCORE;
+var init_profile = __esm({
+  "src/profile.ts"() {
+    "use strict";
+    init_src();
+    TERMINALHIRE_DIR = join3(homedir(), ".terminalhire");
+    PROFILE_FILE = join3(TERMINALHIRE_DIR, "profile.enc");
+    KEY_FILE = join3(TERMINALHIRE_DIR, "key");
+    ALGO = "aes-256-gcm";
+    KEY_BYTES = 32;
+    IV_BYTES = 12;
+    DECAY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+    LANGUAGE_TAGS2 = /* @__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/jpi-learn.js
+async function run() {
+  try {
+    const args = process.argv.slice(2);
+    const cwdIdx = args.indexOf("--cwd");
+    const cwd = cwdIdx !== -1 && args[cwdIdx + 1] ? args[cwdIdx + 1] : process.cwd();
+    const { extractFingerprint: extractFingerprint2 } = await Promise.resolve().then(() => (init_signal(), signal_exports));
+    const { readProfile: readProfile2, writeProfile: writeProfile2, accumulateSession: accumulateSession2 } = await Promise.resolve().then(() => (init_profile(), profile_exports));
+    const fingerprint = extractFingerprint2(cwd);
+    const profile = await readProfile2();
+    accumulateSession2(
+      profile,
+      fingerprint.skillTags,
+      fingerprint.employerContext,
+      fingerprint.seniorityBand
+    );
+    await writeProfile2(profile);
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+var isMain = process.argv[1]?.endsWith("jpi-learn.js") || process.argv[1]?.endsWith("jpi-learn");
+if (isMain) {
+  run();
+}
+export {
+  run
+};