jobless 1.4.0 → 1.6.0

package/src/lint-cli.js

@@ -0,0 +1,128 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { stdin } from 'node:process';
+import { unifiedDiff } from './diff.js';
+import { fixJobPost, githubAnnotations, lintResult } from './lint.js';
+import { demoPosting } from './hiring.js';
+import { blank, dim, green, print } from './style.js';
+import { copyLetter, printFix, printHelp, printLintReport, printTweet } from './screens.js';
+
+const readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString('utf8');
+};
+
+const POSTING_RE = /\.(md|txt|markdown)$/i;
+
+const walkPostings = (dir, acc = []) => {
+  for (const name of readdirSync(dir).sort()) {
+    if (name.startsWith('.')) continue;
+    const path = join(dir, name);
+    let st;
+    try {
+      st = statSync(path);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) walkPostings(path, acc);
+    else if (POSTING_RE.test(name)) acc.push(path);
+  }
+  return acc;
+};
+
+const collectPostings = (paths) => {
+  const files = [];
+  for (const path of paths) {
+    const st = statSync(path);
+    if (st.isDirectory()) walkPostings(path, files);
+    else files.push(path);
+  }
+  return files;
+};
+
+const lintOne = (text, source, { off, fix, write }) => {
+  const report = lintResult(text, source, { off });
+  if (fix || write) {
+    const fixed = fixJobPost(text, { off });
+    report.fix = {
+      applied: fixed.applied,
+      text: fixed.text,
+      path: source,
+      before: text,
+      diff: unifiedDiff(text, fixed.text, source === 'stdin' || source === 'paste' ? 'posting.txt' : source),
+    };
+    if (write && source !== 'stdin' && source !== 'paste' && fixed.applied.length) {
+      writeFileSync(source, fixed.text);
+      report.fix.wrote = true;
+    }
+  }
+  return report;
+};
+
+export const runLintCli = async (files, options) => {
+  const { format = 'pretty', fix = false, write = false, copy = false, quiet = false, off = [], maxWarnings, tweet = false, demo = false } = options;
+
+  const inputs = [];
+  if (demo) {
+    if (files.length || write) throw new Error('--demo cannot be combined with files or --write');
+    inputs.push({ source: 'demo', text: demoPosting });
+  } else if (files[0]) {
+    const paths = collectPostings(files);
+    if (!paths.length) {
+      print(dim(`  no .md/.txt postings under ${files.join(', ')}`));
+      process.exitCode = 1;
+      return;
+    }
+    for (const path of paths) {
+      inputs.push({ source: path, text: readFileSync(path, 'utf8') });
+    }
+  } else if (!stdin.isTTY) {
+    inputs.push({ source: 'stdin', text: await readStdin() });
+  } else {
+    printHelp();
+    blank();
+    print(dim('  lint needs a file, a directory, a pipe, or an interactive paste: npx jobless lint jobs/'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const reports = inputs.map((input) => lintOne(input.text, input.source, { off, fix: fix || write, write }));
+  const lastReport = reports.at(-1);
+
+  let failed = false;
+  for (const report of reports) {
+    if (!report.ok) failed = true;
+    if (maxWarnings != null && report.warnings > maxWarnings) failed = true;
+  }
+  if (failed) process.exitCode = 1;
+
+  if (format === 'json') {
+    print(JSON.stringify(reports.length === 1 ? reports[0] : { reports }, null, 2));
+    if (copy && lastReport?.letter) copyLetter(lastReport.letter);
+    return;
+  }
+
+  if (format === 'github') {
+    const body = reports.map((report) => githubAnnotations(report)).filter(Boolean).join('\n');
+    if (body) print(body);
+    return;
+  }
+
+  for (const [index, report] of reports.entries()) {
+    if (index) blank();
+    const copied = copy && report.letter ? copyLetter(report.letter) : false;
+    printLintReport(report, { quiet, copied });
+    if (report.fix?.applied.length) printFix(report.fix);
+    if (report.fix?.wrote) print(`  ${green('wrote')} ${report.source}`);
+  }
+
+  if (tweet) {
+    blank();
+    printTweet(lastReport);
+  }
+
+  blank();
+  print(dim('  more: npx jobless   ·   npx jobless hire'));
+};
+

package/src/lint-screens.js

@@ -0,0 +1,114 @@
+import { unifiedDiff } from './diff.js';
+import { rules } from './lint.js';
+import { printCompanyReject } from './reject.js';
+import {
+  blank,
+  bold,
+  dim,
+  green,
+  print,
+  red,
+  section,
+  yellow,
+} from './style.js';
+
+export const printLintReport = (report, { quiet = false, copied = false } = {}) => {
+  const { findings, source, errors, warnings, letter, ok, score } = report;
+  const visible = quiet ? findings.filter((item) => item.level === 'error') : findings;
+
+  blank();
+  section('JOBLESS LINT');
+  print(dim('  A rule-based satire score, not an employer rating.'));
+  blank();
+  print(`  ${dim(source)}  ${dim('·')}  ${bold(`${score}/100`)}`);
+  blank();
+
+  if (ok && !findings.length) {
+    print(`  ${green('clean')}  this posting might be a real job.`);
+    if (report.fit) printFit(report.fit, { failed: false });
+    blank();
+    print(`  ${dim('If you still want the engineer who wrote the linter:')} ${bold(green('h'))}`);
+    return report;
+  }
+
+  for (const finding of visible) {
+    const tag = finding.level === 'error' ? red('error') : yellow('warn ');
+    print(`  ${tag}  ${finding.message}`);
+    print(`        ${dim(finding.id)}`);
+    if (finding.line && finding.snippet) {
+      print(`        ${dim(`L${finding.line}`)}  ${finding.snippet}`);
+    }
+    blank();
+  }
+
+  printCompanyReject(letter);
+  if (report.fit) printFit(report.fit, { failed: true });
+  blank();
+  print(
+    `  ${bold(`${score}/100`)}  ${errors} error${errors === 1 ? '' : 's'}  ${warnings} warning${warnings === 1 ? '' : 's'}  ${dim('·')}  ${dim('hire:')} ${bold(green('h'))}${dim('  copy letter:')} ${bold('c')}`,
+  );
+  if (copied) {
+    print(`  ${green('copied')} rejection letter`);
+  }
+  return report;
+};
+
+export const printFit = (fit, { failed = false } = {}) => {
+  if (!fit) return;
+  blank();
+  section('FIT');
+  blank();
+  if (fit.matched.length) print(`  ${green('overlap')}  ${fit.matched.join(dim('  ·  '))}`);
+  if (fit.missed.length) print(`  ${yellow('miss')}     ${fit.missed.join(dim('  ·  '))}`);
+  if (fit.extra.length) print(`  ${dim('also')}     ${fit.extra.join('  ·  ')}`);
+  blank();
+  if (fit.score == null) {
+    print(`  ${dim('The posting did not name a stack. The engineer still exists.')} ${bold(green('h'))}`);
+  } else if (failed) {
+    print(
+      `  ${bold(`${fit.score}/100`)} overlap  ${dim('·')}  ${dim('the posting failed. the engineer still matches:')} ${bold(green('h'))}`,
+    );
+  } else {
+    print(
+      `  ${bold(`${fit.score}/100`)} overlap  ${dim('·')}  ${dim('hire the engineer who matches:')} ${bold(green('h'))}`,
+    );
+  }
+};
+
+export const printFix = (fixed) => {
+  blank();
+  section('DIFF');
+  blank();
+  if (!fixed.applied.length) {
+    print(`  ${dim('nothing to rewrite.')}`);
+    return;
+  }
+  print(`  ${dim('applied')} ${fixed.applied.join('  ·  ')}`);
+  blank();
+  const diff = fixed.diff || unifiedDiff(fixed.before || '', fixed.text, fixed.path || 'posting.txt');
+  if (!diff) {
+    print(`  ${dim('rewrite produced the same lines.')}`);
+    return;
+  }
+  for (const line of diff.split('\n')) {
+    if (line.startsWith('+') && !line.startsWith('+++')) print(`  ${green(line)}`);
+    else if (line.startsWith('-') && !line.startsWith('---')) print(`  ${red(line)}`);
+    else print(`  ${dim(line)}`);
+  }
+};
+
+export const printRules = () => {
+  blank();
+  section('RULES');
+  blank();
+  for (const rule of rules) {
+    const tag = rule.level === 'error' ? red('error') : yellow('warn ');
+    print(`  ${tag}  ${rule.id}`);
+    print(`        ${dim(rule.message)}`);
+    if (rule.why) print(`        ${dim(rule.why)}`);
+    blank();
+  }
+  print(`  ${dim('npx jobless lint --off=rockstar-ninja posting.txt')}`);
+  print(`  ${dim('jobless-disable-next-line no-fake-salary')}`);
+};
+