jobless 1.4.0 → 1.6.0

package/src/lint.js

@@ -1,3 +1,4 @@
+import { fitAgainst } from './fit.js';
 import { detectIdentity } from './identity.js';
 
 const hasMoney = (text) =>
@@ -8,93 +9,454 @@ const roundCount = (text) => {
   return matches.reduce((max, match) => Math.max(max, Number(match[1])), 0);
 };
 
+const stripTakehomeNegation = (text) =>
+  text.replace(/\b(no|without|not a|paid)\s+(take[- ]home|takehome)s?\b/gi, '');
+
+const clip = (value, max = 72) => {
+  const text = String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+
+export const locate = (text, needle) => {
+  if (!needle) return { line: null, snippet: null };
+  const lines = String(text).split(/\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = lines[i].match(needle);
+    if (match) {
+      const snippet = clip(match[0].length >= 8 ? match[0] : lines[i]);
+      return { line: i + 1, snippet };
+    }
+  }
+  const match = String(text).match(needle);
+  if (!match) return { line: null, snippet: null };
+  const line = String(text).slice(0, match.index).split(/\n/).length;
+  return { line, snippet: clip(match[0]) };
+};
+
+const isDirective = (line) => /jobless-disable(?:-next-line|-line|-file)?\b/i.test(line);
+
+export const locateAll = (text, needle) => {
+  if (!needle) return [];
+  const hits = [];
+  const lines = String(text).split('\n');
+  for (let i = 0; i < lines.length; i += 1) {
+    if (isDirective(lines[i])) continue;
+    const match = lines[i].match(needle);
+    if (match) {
+      hits.push({
+        line: i + 1,
+        snippet: clip(match[0].length >= 8 ? match[0] : lines[i]),
+      });
+    }
+  }
+  return hits;
+};
+
+export const parseDisables = (text) => {
+  const lines = String(text).split('\n');
+  const lineMap = new Map();
+  const file = new Set();
+  const idsFrom = (raw) =>
+    raw
+      ? raw
+          .split(/\s*,\s*/)
+          .map((item) => item.trim())
+          .filter(Boolean)
+      : ['*'];
+  const add = (line, ids) => {
+    const set = lineMap.get(line) || new Set();
+    for (const id of ids) set.add(id);
+    lineMap.set(line, set);
+  };
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const next = line.match(/jobless-disable-next-line(?:\s+([a-z0-9-]+(?:\s*,\s*[a-z0-9-]+)*))?/i);
+    if (next) {
+      add(i + 2, idsFrom(next[1]));
+      continue;
+    }
+    const one = line.match(/jobless-disable-line(?:\s+([a-z0-9-]+(?:\s*,\s*[a-z0-9-]+)*))?/i);
+    if (one) {
+      add(i + 1, idsFrom(one[1]));
+      continue;
+    }
+    const whole = line.match(/jobless-disable-file(?:\s+([a-z0-9-]+(?:\s*,\s*[a-z0-9-]+)*))?/i);
+    if (whole) {
+      for (const id of idsFrom(whole[1])) file.add(id);
+    }
+  }
+
+  return { lineMap, file };
+};
+
+const ruleDisabledOn = (disables, line, ruleId) => {
+  if (disables.file.has('*') || disables.file.has(ruleId)) return true;
+  if (line == null) return false;
+  const set = disables.lineMap.get(line);
+  return Boolean(set && (set.has('*') || set.has(ruleId)));
+};
+
+const PLACEHOLDER_PAY = '\n\nSalary range: $120,000–$160,000 (placeholder — put the real range).';
+
 export const rules = [
   {
     id: 'no-fake-salary',
     level: 'error',
     message: 'salary described as competitive / attractive / market-rate, with no number',
+    why: 'If you can name the role, you can name the range.',
+    needle: /\b(competitive|attractive|market[- ]rate)\b.{0,24}\b(salary|compensat\w*|pay|package)\b|\b(salary|compensat\w*|pay|package)\b.{0,24}\b(competitive|attractive|market[- ]rate)\b/i,
     test: (text) =>
       /\b(competitive|attractive|market[- ]rate)\b/i.test(text) &&
       /\b(salary|compensat|pay|package)\b/i.test(text) &&
       !hasMoney(text),
+    fix: (text) => (hasMoney(text) ? text : `${text.trim()}${PLACEHOLDER_PAY}`),
   },
   {
     id: 'no-salary-range',
     level: 'error',
     message: 'no salary range anywhere in the posting',
+    why: 'Compensation is a number. "Competitive" is a vibe.',
     test: (text) => !hasMoney(text) && !/\bsalary range\b|\bcompensation range\b/i.test(text),
+    fix: (text) => (hasMoney(text) ? text : `${text.trim()}${PLACEHOLDER_PAY}`),
   },
   {
     id: 'max-rounds',
     level: 'error',
     message: 'too many interview rounds',
+    why: 'Five-plus rounds is a process, not a signal.',
+    needle: /(\d+)\s*\+?\s*(interview\s+)?(rounds?|stages?|steps?)\b|(six|seven|eight)\s+(interview\s+)?rounds?\b/i,
     test: (text) => roundCount(text) >= 5 || /\b(six|seven|eight)\s+(interview\s+)?rounds\b/i.test(text),
+    fix: (text) =>
+      text
+        .replace(/\b(six|seven|eight|\d+)\s+(interview\s+)?rounds?\b/gi, '3 interview rounds')
+        .replace(/\b(six|seven|eight|\d+)\s+(interview\s+)?(stages?|steps?)\b/gi, '3 interview rounds'),
   },
   {
     id: 'unpaid-takehome',
     level: 'error',
     message: 'take-home that looks like unpaid work',
+    why: 'If it ships value, pay for it.',
+    needle: /\b(take[- ]home|takehome|homework|unpaid (assignment|project)|weekend (project|assignment))\b/i,
     test: (text) => {
-      const stripped = text.replace(/\b(no|without|not a|paid)\s+(take[- ]home|takehome)s?\b/gi, '');
+      const stripped = stripTakehomeNegation(text);
       return /\b(take[- ]home|takehome|homework|unpaid (assignment|project)|weekend (project|assignment))\b/i.test(
         stripped,
       );
     },
+    fix: (text) =>
+      text.replace(
+        /\b(unpaid\s+)?(take[- ]home|takehome|homework)s?\b/gi,
+        'paid time-boxed work sample',
+      ),
+  },
+  {
+    id: 'unbounded-takehome',
+    level: 'error',
+    message: 'take-home with no time box',
+    why: 'Unbounded homework is just the roadmap with a Sunday deadline.',
+    needle: /\b(take[- ]home|takehome)\b/i,
+    test: (text) => {
+      const stripped = text.replace(/\b(no|without|not a)\s+(take[- ]home|takehome)s?\b/gi, '');
+      const hasTakehome = /\b(take[- ]home|takehome)\b/i.test(stripped);
+      const hasBudget = /\b(\d+\s*(hour|hr)s?|time[- ]boxed|timeboxed)\b/i.test(text);
+      return hasTakehome && !hasBudget;
+    },
+    fix: (text) => `${text.trim()}\n\nAny work sample is paid and time-boxed to 3 hours.`,
   },
   {
     id: 'entry-needs-years',
     level: 'error',
     message: 'entry-level / junior role asking for years of experience',
+    why: 'Junior is not a synonym for cheap senior.',
+    needle: /\b(entry[- ]level|junior)\b/i,
     test: (text) =>
-      /\b(entry[- ]level|junior)\b/i.test(text) &&
-      /\b([3-9]|[1-9]\d)\+?\s+years?\b/i.test(text),
+      /\b(entry[- ]level|junior)\b/i.test(text) && /\b([3-9]|[1-9]\d)\+?\s+years?\b/i.test(text),
+    fix: (text) => text.replace(/\b(entry[- ]level|junior)\b/gi, 'this'),
+  },
+  {
+    id: 'nights-and-weekends',
+    level: 'error',
+    message: 'nights, weekends, or crunch as a requirement',
+    why: 'Crunch in the posting is crunch in the job.',
+    needle: /\b(nights and weekends|crunch|weekends required|on[- ]call 24)\b/i,
+    test: (text) => /\b(nights and weekends|crunch|weekends required|on[- ]call 24)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(nights and weekends|crunch|weekends required|on[- ]call 24\/?7?)\b/gi,
+        'weekday hours; on-call is compensated',
+      ),
+  },
+  {
+    id: 'remote-but-office',
+    level: 'error',
+    message: 'lists remote, then requires the office',
+    why: 'Remote means remote. The office is a different job.',
+    needle: /\b(in[- ]office|on[- ]site|5 days (a|in) (the )?office)\b/i,
+    test: (text) =>
+      /\bremote\b/i.test(text) &&
+      /\b(in[- ]office 5|on[- ]site 5|5 days (a|in) (the )?office|must be in (the )?office)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b,?\s*must be in (the )?office(\s+\d+\s+days)?\b/gi,
+        '',
+      ).replace(/\b(in[- ]office|on[- ]site)\s+5 days\b/gi, 'remote'),
+  },
+  {
+    id: 'equity-only',
+    level: 'error',
+    message: 'equity / competitive equity with no number',
+    why: 'Equity without a percentage is a lottery ticket with no odds.',
+    needle: /\b(competitive equity|equity-only|paid in equity)\b/i,
+    test: (text) =>
+      /\b(competitive equity|equity-only|paid in equity)\b/i.test(text) && !/%|\bpercent\b/i.test(text),
+    fix: (text) => `${text.trim()}\n\nEquity: stated percentage (placeholder — put the real grant).`,
   },
   {
     id: 'means-understaffed',
     level: 'warn',
     message: '"fast-paced" / "wear many hats" / "do more with less"',
+    why: 'Usually means understaffed and proud of it.',
+    needle: /\bfast[- ]paced\b|\bwear many hats\b|\bdo more with less\b|\bhustle\b|\blean team\b/i,
     test: (text) =>
       /\bfast[- ]paced\b|\bwear many hats\b|\bdo more with less\b|\bhustle\b|\blean team\b/i.test(text),
+    fix: (text) =>
+      text
+        .replace(/\bfast[- ]paced\b/gi, 'staffed')
+        .replace(/\bwear many hats\b/gi, 'have a defined role')
+        .replace(/\bdo more with less\b/gi, 'have enough people')
+        .replace(/\bhustle\b/gi, 'ship')
+        .replace(/\blean team\b/gi, 'team'),
   },
   {
     id: 'rockstar-ninja',
     level: 'warn',
     message: 'rockstar / ninja / 10x / guru',
+    why: 'Hire an engineer. The costume closet is full.',
+    needle: /\b(rockstar|ninja|10x|guru|superstar|wizard|code monkey)s?\b/i,
     test: (text) => /\b(rockstar|ninja|10x|guru|superstar|wizard|code monkey)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(?:(rockstar|ninja|10x|guru|superstar|wizard|code monkey)s?\s*)+/gi,
+        'engineer ',
+      ),
   },
   {
     id: 'we-are-family',
     level: 'warn',
     message: 'we are a family',
+    why: 'Families do not PIP you. Companies do.',
+    needle: /\b(we['’]re a family|we are a family|our family|work family)\b/i,
     test: (text) => /\b(we['’]re a family|we are a family|our family|work family)\b/i.test(text),
+    fix: (text) =>
+      text
+        .replace(/\b(?:who is )?passionate about (?:our family|we['’]re a family|we are a family)\b/gi, '')
+        .replace(/\b(we['’]re a family|we are a family|our family|work family)\b/gi, "we're a team")
+        .replace(/[ ]{2,}/g, ' '),
   },
   {
     id: 'unlimited-pto',
     level: 'warn',
     message: 'unlimited PTO (often means unused PTO)',
+    why: 'Unlimited usually means unused. Write the days.',
+    needle: /\bunlimited (pto|vacation|time off)\b/i,
     test: (text) => /\bunlimited (pto|vacation|time off)\b/i.test(text),
-  },
-  {
-    id: 'nights-and-weekends',
-    level: 'error',
-    message: 'nights, weekends, or crunch as a requirement',
-    test: (text) => /\b(nights and weekends|crunch|weekends required|on[- ]call 24)\b/i.test(text),
+    fix: (text) => text.replace(/\bunlimited (pto|vacation|time off)\b/gi, 'accrued PTO with a stated balance'),
   },
   {
     id: 'passion-tax',
     level: 'warn',
     message: 'looking for passion instead of paying for labor',
+    why: 'Passion is not a compensation strategy.',
+    needle: /\b(passionate about|must love|looking for passion)\b/i,
     test: (text) => /\b(passionate about|must love|looking for passion)\b/i.test(text),
+    fix: (text) =>
+      text
+        .replace(/\bpassionate about\b/gi, 'experienced in')
+        .replace(/\bmust love\b/gi, 'will work on')
+        .replace(/\blooking for passion\b/gi, 'hiring for skill'),
+  },
+  {
+    id: 'founding-engineer-theater',
+    level: 'warn',
+    message: '"founding engineer" at a company that already has a team',
+    why: 'Founding is a round, not a vibe on a 200-person roster.',
+    needle: /\bfounding engineer\b/i,
+    test: (text) =>
+      /\bfounding engineer\b/i.test(text) &&
+      /\b(\d{2,}\+?\s+(people|employees|engineers)|hundreds? of)\b/i.test(text),
+    fix: (text) => text.replace(/\bfounding engineer\b/gi, 'engineer'),
+  },
+  {
+    id: 'visa-silence',
+    level: 'warn',
+    message: 'global / anywhere posting with no visa or sponsorship mention',
+    why: 'Worldwide without a visa sentence is a filter, not a welcome.',
+    needle: /\b(worldwide|global team|work from anywhere|anywhere in the world)\b/i,
+    test: (text) =>
+      /\b(worldwide|global team|work from anywhere|anywhere in the world)\b/i.test(text) &&
+      !/\b(visa|sponsor|sponsorship|work authorization)\b/i.test(text),
+    fix: (text) => `${text.trim()}\n\nVisa / sponsorship: say yes or no, in writing.`,
+  },
+  {
+    id: 'ai-first-vapor',
+    level: 'warn',
+    message: '"AI-first" / "AI-powered" with no product sentence',
+    why: 'If there is no product, there is no AI-first. There is a deck.',
+    needle: /\bai[- ]first\b|\bai[- ]powered\b/i,
+    test: (text) =>
+      /\bai[- ]first\b|\bai[- ]powered\b/i.test(text) &&
+      !/\b(product|users|customers|shipped|revenue)\b/i.test(text),
+    fix: (text) =>
+      text.replace(/\bai[- ]first\b/gi, 'product').replace(/\bai[- ]powered\b/gi, 'product'),
+  },
+  {
+    id: 'culture-fit',
+    level: 'warn',
+    message: 'culture fit / young and hungry / work hard play hard',
+    why: 'Code for hours that are not written down.',
+    needle: /\bculture fit\b|\byoung and hungry\b|\bwork hard[, ]+play hard\b/i,
+    test: (text) =>
+      /\bculture fit\b|\byoung and hungry\b|\bwork hard[, ]+play hard\b/i.test(text),
+    fix: (text) =>
+      text
+        .replace(/\bculture fit\b/gi, 'can do the job')
+        .replace(/\byoung and hungry\b/gi, 'experienced')
+        .replace(/\bwork hard[, ]+play hard\b/gi, 'work hours that are written down'),
+  },
+  {
+    id: 'exact-stack-religion',
+    level: 'warn',
+    message: 'must have used this exact stack in production',
+    why: 'Strong engineers learn stacks. Exact-match is a recruiter checkbox.',
+    needle: /\b(exact stack|our exact|must have (used|experience with) our)\b/i,
+    test: (text) => /\b(exact stack|our exact|must have (used|experience with) our)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(must have (used|experience with) our exact stack|our exact stack|exact stack)\b/gi,
+        'strong engineers who can learn the stack',
+      ),
+  },
+  {
+    id: 'salary-doe',
+    level: 'error',
+    message: 'salary is DOE / commensurate with experience, with no number',
+    why: 'DOE is competitive with extra steps.',
+    needle: /\b(DOE|D\.O\.E\.|commensurate with experience)\b/i,
+    test: (text) => /\b(DOE|D\.O\.E\.|commensurate with experience)\b/i.test(text) && !hasMoney(text),
+    fix: (text) => (hasMoney(text) ? text : `${text.trim()}${PLACEHOLDER_PAY}`),
+  },
+  {
+    id: 'ancient-years',
+    level: 'error',
+    message: 'too many years required for a young tool',
+    why: 'Next.js is not old enough to demand a decade.',
+    needle: /\b(8|9|[1-9]\d)\+?\s+years?\b.{0,40}\b(next\.js|graphql|kubernetes|typescript|tailwind)\b/i,
+    test: (text) =>
+      /\b(8|9|[1-9]\d)\+?\s+years?\b.{0,40}\b(next\.js|graphql|kubernetes|typescript|tailwind)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(8|9|[1-9]\d)\+?\s+years? (of |with )?(next\.js|graphql|kubernetes|typescript|tailwind)\b/gi,
+        'production experience with $3',
+      ),
+  },
+  {
+    id: 'perk-theater',
+    level: 'warn',
+    message: 'snacks / ping-pong / kombucha listed as a benefit',
+    why: 'A fridge is not a benefits package.',
+    needle: /\b(ping[- ]pong|foosball|kombucha|beer fridge|free snacks|snack bar|nap pod)\b/i,
+    test: (text) =>
+      /\b(ping[- ]pong|foosball|kombucha|beer fridge|free snacks|snack bar|nap pod)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(ping[- ]pong|foosball|kombucha|beer fridge|free snacks|snack bar|nap pod)( and )?/gi,
+        '',
+      ),
+  },
+  {
+    id: 'native-english',
+    level: 'error',
+    message: 'native English as a filter',
+    why: 'Fluent is a skill. Native is a census category.',
+    needle: /\b(native english|english native speaker|native speaker of english)\b/i,
+    test: (text) => /\b(native english|english native speaker|native speaker of english)\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(native english|english native speaker|native speaker of english)\b/gi,
+        'clear written and spoken English',
+      ),
+  },
+  {
+    id: 'unpaid-trial',
+    level: 'error',
+    message: 'contract-to-hire / trial that looks unpaid',
+    why: 'A trial is a job. Jobs are paid.',
+    needle: /\b(contract[- ]to[- ]hire|unpaid trial|trial period)\b/i,
+    test: (text) =>
+      /\bunpaid trial\b/i.test(text) ||
+      (/\bcontract[- ]to[- ]hire\b/i.test(text) && /\bunpaid\b/i.test(text)),
+    fix: (text) =>
+      text.replace(/\bunpaid trial\b/gi, 'paid trial').replace(/\bcontract[- ]to[- ]hire\b/gi, 'full-time role'),
+  },
+  {
+    id: 'fake-startup',
+    level: 'warn',
+    message: '"startup energy" at a company that already has a headcount',
+    why: 'Startup is a stage. Headcount is a fact.',
+    needle: /\bstartup (energy|culture|vibe|feel)\b/i,
+    test: (text) =>
+      /\bstartup (energy|culture|vibe|feel)\b/i.test(text) &&
+      /\b(\d{3,}|\d+\s*k|\bthousands?)\s+(people|employees|engineers)\b/i.test(text),
+    fix: (text) => text.replace(/\bstartup (energy|culture|vibe|feel)\b/gi, 'company'),
+  },
+  {
+    id: 'degree-when-years',
+    level: 'warn',
+    message: 'degree required on a role that already asks for years',
+    why: 'Five years in production already sat the exam.',
+    needle: /\b(bachelor|bachelor'?s|bs\/ms|degree required|must have a degree)\b/i,
+    test: (text) =>
+      /\b(bachelor|bachelor'?s|bs\/ms|degree required|must have a degree)\b/i.test(text) &&
+      /\b([5-9]|[1-9]\d)\+?\s+years?\b/i.test(text),
+    fix: (text) =>
+      text.replace(
+        /\b(bachelor'?s degree|bachelor degree|bs\/ms|degree required|must have a degree)\b/gi,
+        'relevant experience',
+      ),
   },
 ];
 
-export const lintJobPost = (raw) => {
+const disabledSet = (off = []) =>
+  new Set(
+    (Array.isArray(off) ? off : String(off).split(','))
+      .map((id) => String(id).trim())
+      .filter(Boolean),
+  );
+
+export const lintJobPost = (raw, { off = [] } = {}) => {
   const text = String(raw || '').trim();
+  const disabled = disabledSet(off);
+  const disables = parseDisables(text);
   if (!text) {
-    return { text, findings: [{ id: 'empty', level: 'error', message: 'no job description provided' }] };
+    return { text, findings: [{ id: 'empty', level: 'error', message: 'no job description provided', line: null, snippet: null }] };
   }
 
-  const findings = rules.filter((rule) => rule.test(text)).map(({ id, level, message }) => ({ id, level, message }));
+  const findings = [];
+  for (const rule of rules) {
+    if (disabled.has(rule.id) || disables.file.has(rule.id) || disables.file.has('*')) continue;
+    if (!rule.test(text)) continue;
+    if (rule.needle) {
+      const hits = locateAll(text, rule.needle).filter((hit) => !ruleDisabledOn(disables, hit.line, rule.id));
+      if (!hits.length) continue;
+      findings.push({ id: rule.id, level: rule.level, message: rule.message, why: rule.why, ...hits[0] });
+      continue;
+    }
+    findings.push({ id: rule.id, level: rule.level, message: rule.message, why: rule.why, line: null, snippet: null });
+  }
   return { text, findings };
 };
 
@@ -104,35 +466,60 @@ export const summarizeLint = (findings) => {
   return { errors, warnings };
 };
 
+export const scoreLint = (errors, warnings) => Math.max(0, Math.min(100, 100 - errors * 18 - warnings * 8));
+
+const COMPANY_STOP =
+  /^(Competitive|Attractive|Salary|Compensation|Remote|We|Our|The|This|Looking|Join|About|Fast|Unlimited|Senior|Staff|A|An|Full)$/i;
+
 export const postingMeta = (text) => {
-  const roleMatch = String(text || '').match(
-    /\b(?:senior|staff|principal|lead|junior|entry[- ]level)?[ \t]*(?:full[- ]stack|frontend|backend|software|platform)?[ \t]*(?:engineer|developer|designer)\b/i,
+  const raw = String(text || '');
+  const flat = raw.replace(/\s+/g, ' ');
+  const roleMatch = flat.match(
+    /\b(?:senior|staff|principal|lead|junior|entry[- ]level)?\s*(?:full[- ]stack|frontend|backend|software|platform)?\s*(?:engineer|developer|designer)\b/i,
+  );
+  const fromJoinUs = raw.match(
+    /\bjoin us at[ \t]+([A-Z][A-Za-z0-9&.'\-]{1,32}(?:[ \t]+[A-Z][A-Za-z0-9&.'\-]{1,20}){0,2})/i,
   );
-  const atMatch = String(text || '').match(
+  const fromAt = raw.match(
     /\b(?:at|@|join)[ \t]+([A-Z][A-Za-z0-9&.'\-]{1,32}(?:[ \t]+[A-Z][A-Za-z0-9&.'\-]{1,20}){0,2})/,
   );
+  const fromHiring = raw.match(
+    /\b([A-Z][A-Za-z0-9&.'\-]{1,32}(?:[ \t]+[A-Z][A-Za-z0-9&.'\-]{1,20}){0,2})[ \t]+is hiring\b/,
+  );
+  const captured = fromJoinUs?.[1] || fromAt?.[1] || fromHiring?.[1] || '';
+  const company =
+    captured
+      .split(/[ \t]+/)
+      .filter((word) => !COMPANY_STOP.test(word))
+      .join(' ')
+      .trim() || 'Hiring';
+
   return {
     role: roleMatch ? roleMatch[0].replace(/\s+/g, ' ').trim() : 'this role',
-    company: atMatch ? atMatch[1].trim() : 'Hiring',
+    company,
   };
 };
 
-export const lintResult = (raw, source = 'stdin') => {
-  const { text, findings } = lintJobPost(raw);
+export const lintResult = (raw, source = 'stdin', { off = [] } = {}) => {
+  const { text, findings } = lintJobPost(raw, { off });
   const { errors, warnings } = summarizeLint(findings);
   const identity = detectIdentity();
   const meta = postingMeta(text);
   const errorReasons = findings.filter((item) => item.level === 'error').map((item) => item.message);
   const warnReasons = findings.filter((item) => item.level === 'warn').map((item) => item.message);
   const reasons = (errorReasons.length ? errorReasons : warnReasons).slice(0, 2);
+  const score = scoreLint(errors, warnings);
+  const fit = fitAgainst(text);
 
   return {
     source,
     ok: errors === 0,
+    score,
     errors,
     warnings,
     findings,
     meta,
+    fit,
     letter:
       findings.length === 0
         ? null
@@ -145,3 +532,41 @@ export const lintResult = (raw, source = 'stdin') => {
           },
   };
 };
+
+export const fixJobPost = (raw, { off = [] } = {}) => {
+  const disabled = disabledSet(off);
+  let text = String(raw || '');
+  const applied = [];
+  for (const rule of rules) {
+    if (disabled.has(rule.id) || !rule.fix) continue;
+    if (!rule.test(text)) continue;
+    const next = rule.fix(text);
+    if (next !== text) {
+      applied.push(rule.id);
+      text = next;
+    }
+  }
+  text = polishFix(text);
+  return { text, applied };
+};
+
+const polishFix = (text) =>
+  String(text)
+    .replace(/\ba engineer\b/gi, 'an engineer')
+    .replace(/\bwho is we're a team\b/gi, '')
+    .replace(/\bis we're a team\b/gi, 'is a team')
+    .replace(/[ ]{2,}/g, ' ')
+    .replace(/ +([.,;:])/g, '$1')
+    .replace(/ +\n/g, '\n');
+
+export const githubAnnotations = (report) =>
+  report.findings
+    .map((finding) => {
+      const kind = finding.level === 'error' ? 'error' : 'warning';
+      const file =
+        !report.source || report.source === 'stdin' || report.source === 'paste' ? 'posting.txt' : report.source;
+      const line = finding.line ? `,line=${finding.line}` : '';
+      const title = finding.id ? `,title=${finding.id}` : '';
+      return `::${kind} file=${file}${line}${title}::${finding.message}`;
+    })
+    .join('\n');