job-forge 2.14.29 → 2.14.31

package/lib/jobforge-facts.mjs

@@ -0,0 +1,178 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import {
+  buildFacts,
+  checkFactRequirements,
+  factId,
+  hasFact,
+  loadFactsConfig,
+  parseJson,
+  queryFacts,
+  verifyFactSet,
+} from '@razroo/iso-facts';
+import {
+  jobForgeCompanyRoleKey,
+  jobForgeUrlKey,
+  legacyCompanyRoleKey,
+  legacyUrlKey,
+} from './jobforge-canon.mjs';
+
+export const FACTS_FILE = '.jobforge-facts.json';
+export const FACTS_CONFIG_FILE = 'templates/facts.json';
+
+export function resolveProjectDir(projectDir = process.env.JOB_FORGE_PROJECT || process.cwd()) {
+  return projectDir;
+}
+
+export function jobForgeFactsPath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_FACTS || join(projectDir, FACTS_FILE);
+}
+
+export function jobForgeFactsConfigPath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_FACTS_CONFIG || join(projectDir, FACTS_CONFIG_FILE);
+}
+
+export function factsExist(projectDir = resolveProjectDir()) {
+  return existsSync(jobForgeFactsPath(projectDir));
+}
+
+export function readJobForgeFactsConfig(projectDir = resolveProjectDir()) {
+  const path = jobForgeFactsConfigPath(projectDir);
+  return loadFactsConfig(parseJson(readFileSync(path, 'utf8'), path));
+}
+
+export function buildJobForgeFacts(options = {}, projectDir = resolveProjectDir()) {
+  const config = readJobForgeFactsConfig(projectDir);
+  const factSet = canonicalizeJobForgeFacts(buildFacts(config, { root: projectDir }), projectDir);
+  const out = options.out || jobForgeFactsPath(projectDir);
+  if (options.write !== false) {
+    writeFileSync(out, `${JSON.stringify(factSet, null, 2)}\n`, 'utf8');
+  }
+  return { factSet, out };
+}
+
+export function readJobForgeFacts(projectDir = resolveProjectDir()) {
+  const path = jobForgeFactsPath(projectDir);
+  return parseJson(readFileSync(path, 'utf8'), path);
+}
+
+export function ensureJobForgeFacts(options = {}, projectDir = resolveProjectDir()) {
+  if (options.rebuild !== false || !factsExist(projectDir)) {
+    return buildJobForgeFacts({ out: options.out }, projectDir).factSet;
+  }
+  return readJobForgeFacts(projectDir);
+}
+
+export function queryJobForgeFacts(query = {}, options = {}, projectDir = resolveProjectDir()) {
+  return queryFacts(ensureJobForgeFacts(options, projectDir), query);
+}
+
+export function hasJobForgeFact(query = {}, options = {}, projectDir = resolveProjectDir()) {
+  return hasFact(ensureJobForgeFacts(options, projectDir), query);
+}
+
+export function verifyJobForgeFacts(options = {}, projectDir = resolveProjectDir()) {
+  const factSet = options.factSet || ensureJobForgeFacts(options, projectDir);
+  return verifyFactSet(factSet);
+}
+
+export function checkJobForgeFacts(options = {}, projectDir = resolveProjectDir()) {
+  const factSet = options.factSet || ensureJobForgeFacts(options, projectDir);
+  const config = readJobForgeFactsConfig(projectDir);
+  return checkFactRequirements(factSet, config.requirements || []);
+}
+
+export function jobForgeFactsSummary(projectDir = resolveProjectDir()) {
+  if (!factsExist(projectDir)) {
+    return {
+      path: jobForgeFactsPath(projectDir),
+      config: jobForgeFactsConfigPath(projectDir),
+      exists: false,
+      facts: 0,
+      files: 0,
+      sources: 0,
+    };
+  }
+  const factSet = readJobForgeFacts(projectDir);
+  return {
+    path: jobForgeFactsPath(projectDir),
+    config: jobForgeFactsConfigPath(projectDir),
+    exists: true,
+    facts: factSet.stats?.facts || 0,
+    files: factSet.stats?.files || 0,
+    sources: factSet.stats?.sources || 0,
+    configHash: factSet.configHash,
+  };
+}
+
+function canonicalizeJobForgeFacts(factSet, projectDir) {
+  const facts = (factSet.facts || []).map((fact) => canonicalizeJobForgeFact(fact, projectDir));
+  facts.sort(compareFacts);
+  return {
+    ...factSet,
+    facts,
+    stats: {
+      ...(factSet.stats || {}),
+      facts: facts.length,
+    },
+  };
+}
+
+function canonicalizeJobForgeFact(fact, projectDir) {
+  const key = canonicalFactKey(fact, projectDir);
+  if (key === fact.key) return fact;
+  const updated = { ...fact, key };
+  return { ...updated, id: factId(updated) };
+}
+
+function canonicalFactKey(fact, projectDir) {
+  if (isCompanyRoleFact(fact)) {
+    const { company, role } = companyRoleFields(fact);
+    if (company && role) return safeCompanyRoleKey(company, role, projectDir);
+  }
+  if (isUrlFact(fact)) {
+    const url = fact.fields?.url;
+    if (url) return safeUrlKey(url, projectDir);
+  }
+  return fact.key;
+}
+
+function isCompanyRoleFact(fact) {
+  return fact.key?.startsWith('company-role:') ||
+    fact.fact === 'application.status' ||
+    fact.fact === 'tracker.addition' ||
+    fact.fact === 'candidate.ready';
+}
+
+function companyRoleFields(fact) {
+  const fields = fact.fields || {};
+  return {
+    company: fields.company || fields.Company,
+    role: fields.role || fields.Role,
+  };
+}
+
+function isUrlFact(fact) {
+  return fact.key?.startsWith('url:') || fact.fact === 'job.url';
+}
+
+function safeCompanyRoleKey(company, role, projectDir) {
+  try {
+    return jobForgeCompanyRoleKey(company, role, projectDir);
+  } catch {
+    return legacyCompanyRoleKey(company, role);
+  }
+}
+
+function safeUrlKey(url, projectDir) {
+  try {
+    return jobForgeUrlKey(url, projectDir);
+  } catch {
+    return legacyUrlKey(url);
+  }
+}
+
+function compareFacts(a, b) {
+  return `${a.fact}\0${a.key || ''}\0${a.value || ''}\0${a.source?.path || ''}\0${a.source?.line || ''}\0${a.id}`
+    .localeCompare(`${b.fact}\0${b.key || ''}\0${b.value || ''}\0${b.source?.path || ''}\0${b.source?.line || ''}\0${b.id}`);
+}

package/lib/jobforge-redact.mjs

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import {
+  loadRedactConfig,
+  parseJson,
+} from '@razroo/iso-redact';
+
+export const REDACT_CONFIG_FILE = 'templates/redact.json';
+
+export function resolveProjectDir(projectDir = process.env.JOB_FORGE_PROJECT || process.cwd()) {
+  return projectDir;
+}
+
+export function jobForgeRedactConfigPath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_REDACT_CONFIG || join(projectDir, REDACT_CONFIG_FILE);
+}
+
+export function redactConfigExists(projectDir = resolveProjectDir()) {
+  return existsSync(jobForgeRedactConfigPath(projectDir));
+}
+
+export function readJobForgeRedactConfig(projectDir = resolveProjectDir()) {
+  const path = jobForgeRedactConfigPath(projectDir);
+  return loadRedactConfig(parseJson(readFileSync(path, 'utf8'), path));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-forge",
-  "version": "2.14.29",
+  "version": "2.14.31",
   "description": "AI-powered job search pipeline built on opencode",
   "type": "module",
   "bin": {
@@ -55,6 +55,13 @@
     "index:has": "node bin/job-forge.mjs index:has",
     "index:verify": "node bin/job-forge.mjs index:verify",
     "index:explain": "node bin/job-forge.mjs index:explain",
+    "facts:build": "node bin/job-forge.mjs facts:build",
+    "facts:status": "node bin/job-forge.mjs facts:status",
+    "facts:verify": "node bin/job-forge.mjs facts:verify",
+    "facts:check": "node bin/job-forge.mjs facts:check",
+    "facts:has": "node bin/job-forge.mjs facts:has",
+    "facts:query": "node bin/job-forge.mjs facts:query",
+    "facts:explain": "node bin/job-forge.mjs facts:explain",
     "canon:normalize": "node bin/job-forge.mjs canon:normalize",
     "canon:key": "node bin/job-forge.mjs canon:key",
     "canon:compare": "node bin/job-forge.mjs canon:compare",
@@ -65,6 +72,10 @@
     "postflight:status": "node bin/job-forge.mjs postflight:status",
     "postflight:check": "node bin/job-forge.mjs postflight:check",
     "postflight:explain": "node bin/job-forge.mjs postflight:explain",
+    "redact:scan": "node bin/job-forge.mjs redact:scan",
+    "redact:verify": "node bin/job-forge.mjs redact:verify",
+    "redact:apply": "node bin/job-forge.mjs redact:apply",
+    "redact:explain": "node bin/job-forge.mjs redact:explain",
     "migrate:plan": "node bin/job-forge.mjs migrate:plan",
     "migrate:apply": "node bin/job-forge.mjs migrate:apply",
     "migrate:check": "node bin/job-forge.mjs migrate:check",
@@ -140,6 +151,7 @@
     "@razroo/iso-capabilities": "^0.1.0",
     "@razroo/iso-context": "^0.1.0",
     "@razroo/iso-contract": "^0.1.0",
+    "@razroo/iso-facts": "^0.1.0",
     "@razroo/iso-guard": "^0.1.0",
     "@razroo/iso-index": "^0.1.0",
     "@razroo/iso-ledger": "^0.1.0",
@@ -147,6 +159,7 @@
     "@razroo/iso-orchestrator": "^0.1.0",
     "@razroo/iso-postflight": "^0.1.0",
     "@razroo/iso-preflight": "^0.1.0",
+    "@razroo/iso-redact": "^0.1.0",
     "@razroo/iso-trace": "^0.4.0",
     "playwright": "^1.58.1"
   },

package/scripts/facts.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+import { relative } from 'path';
+import {
+  formatBuildResult,
+  formatCheckResult,
+  formatConfigSummary,
+  formatFacts,
+  formatVerifyResult,
+} from '@razroo/iso-facts';
+import { PROJECT_DIR } from '../tracker-lib.mjs';
+import {
+  buildJobForgeFacts,
+  checkJobForgeFacts,
+  factsExist,
+  hasJobForgeFact,
+  jobForgeFactsConfigPath,
+  jobForgeFactsPath,
+  jobForgeFactsSummary,
+  queryJobForgeFacts,
+  readJobForgeFactsConfig,
+  verifyJobForgeFacts,
+} from '../lib/jobforge-facts.mjs';
+
+const USAGE = `job-forge facts - local deterministic fact materialization
+
+Usage:
+  job-forge facts:status [--json]
+  job-forge facts:build [--json]
+  job-forge facts:query [text] [--fact <fact>] [--key <key>] [--value <value>] [--source <path>] [--tag <tag>] [--limit N] [--no-rebuild] [--json]
+  job-forge facts:has [text] [--fact <fact>] [--key <key>] [--value <value>] [--source <path>] [--tag <tag>] [--no-rebuild] [--json]
+  job-forge facts:verify [--no-rebuild] [--json]
+  job-forge facts:check [--no-rebuild] [--json]
+  job-forge facts:explain [--json]
+  job-forge facts:path
+
+Default config is templates/facts.json. Default output is .jobforge-facts.json.
+Query, has, verify, and check rebuild facts by default so consumer projects need
+no manual setup. Use --no-rebuild to inspect the existing fact set only.`;
+
+const [cmd = 'help', ...rawArgs] = process.argv.slice(2);
+const opts = parseArgs(rawArgs);
+
+if (opts.help || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(USAGE);
+  process.exit(0);
+}
+
+try {
+  if (cmd === 'path') {
+    console.log(jobForgeFactsPath(PROJECT_DIR));
+  } else if (cmd === 'status') {
+    status(opts);
+  } else if (cmd === 'build') {
+    build(opts);
+  } else if (cmd === 'query') {
+    query(opts);
+  } else if (cmd === 'has') {
+    has(opts);
+  } else if (cmd === 'verify') {
+    verify(opts);
+  } else if (cmd === 'check') {
+    check(opts);
+  } else if (cmd === 'explain') {
+    explain(opts);
+  } else {
+    console.error(`unknown facts command "${cmd}"\n`);
+    console.error(USAGE);
+    process.exit(2);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+
+function parseArgs(args) {
+  const opts = {
+    json: false,
+    help: false,
+    rebuild: true,
+    query: {},
+    text: [],
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      opts.json = true;
+    } else if (arg === '--no-rebuild') {
+      opts.rebuild = false;
+    } else if (arg === '--rebuild') {
+      opts.rebuild = true;
+    } else if (arg === '--fact') {
+      opts.query.fact = valueAfter(args, ++i, '--fact');
+    } else if (arg.startsWith('--fact=')) {
+      opts.query.fact = arg.slice('--fact='.length);
+    } else if (arg === '--key') {
+      opts.query.key = valueAfter(args, ++i, '--key');
+    } else if (arg.startsWith('--key=')) {
+      opts.query.key = arg.slice('--key='.length);
+    } else if (arg === '--value') {
+      opts.query.value = valueAfter(args, ++i, '--value');
+    } else if (arg.startsWith('--value=')) {
+      opts.query.value = arg.slice('--value='.length);
+    } else if (arg === '--source') {
+      opts.query.source = valueAfter(args, ++i, '--source');
+    } else if (arg.startsWith('--source=')) {
+      opts.query.source = arg.slice('--source='.length);
+    } else if (arg === '--tag') {
+      opts.query.tag = valueAfter(args, ++i, '--tag');
+    } else if (arg.startsWith('--tag=')) {
+      opts.query.tag = arg.slice('--tag='.length);
+    } else if (arg === '--limit') {
+      opts.query.limit = parsePositiveInteger(valueAfter(args, ++i, '--limit'), '--limit');
+    } else if (arg.startsWith('--limit=')) {
+      opts.query.limit = parsePositiveInteger(arg.slice('--limit='.length), '--limit');
+    } else if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else if (arg.startsWith('--')) {
+      throw new Error(`unknown flag "${arg}"`);
+    } else {
+      opts.text.push(arg);
+    }
+  }
+
+  if (opts.text.length > 0) opts.query.text = opts.text.join(' ');
+  return opts;
+}
+
+function valueAfter(values, index, flag) {
+  const value = values[index];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function parsePositiveInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${flag} must be a positive integer`);
+  return parsed;
+}
+
+function status(opts) {
+  const summary = jobForgeFactsSummary(PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  if (!summary.exists) {
+    console.log(`facts: missing (${relativePath(summary.path)})`);
+    console.log('run: job-forge facts:build');
+    return;
+  }
+  const result = verifyJobForgeFacts({ rebuild: false }, PROJECT_DIR);
+  console.log(`facts:   ${relativePath(summary.path)}`);
+  console.log(`config:  ${relativePath(summary.config)}`);
+  console.log(`sources: ${summary.sources}`);
+  console.log(`files:   ${summary.files}`);
+  console.log(`facts:   ${summary.facts}`);
+  console.log(`verify:  ${result.ok ? 'PASS' : 'FAIL'} (${result.issues.length} issue(s))`);
+}
+
+function build(opts) {
+  const { factSet, out } = buildJobForgeFacts({}, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify({ out, stats: factSet.stats }, null, 2));
+    return;
+  }
+  console.log(formatBuildResult(factSet, out));
+}
+
+function query(opts) {
+  const facts = queryJobForgeFacts(opts.query, { rebuild: opts.rebuild }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(facts, null, 2));
+    return;
+  }
+  console.log(formatFacts(facts));
+}
+
+function has(opts) {
+  const hit = hasJobForgeFact(opts.query, { rebuild: opts.rebuild }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify({ hit, query: opts.query }, null, 2));
+  } else {
+    console.log(hit ? 'MATCH' : 'MISS');
+  }
+  process.exit(hit ? 0 : 1);
+}
+
+function verify(opts) {
+  if (!opts.rebuild && !factsExist(PROJECT_DIR)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true, missing: true, path: jobForgeFactsPath(PROJECT_DIR) }, null, 2));
+    } else {
+      console.log(`facts: missing (${relativePath(jobForgeFactsPath(PROJECT_DIR))})`);
+    }
+    return;
+  }
+  const result = verifyJobForgeFacts({ rebuild: opts.rebuild }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatVerifyResult(result));
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+function check(opts) {
+  if (!opts.rebuild && !factsExist(PROJECT_DIR)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true, missing: true, path: jobForgeFactsPath(PROJECT_DIR) }, null, 2));
+    } else {
+      console.log(`facts: missing (${relativePath(jobForgeFactsPath(PROJECT_DIR))})`);
+    }
+    return;
+  }
+  const result = checkJobForgeFacts({ rebuild: opts.rebuild }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatCheckResult(result));
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+function explain(opts) {
+  const config = readJobForgeFactsConfig(PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  console.log(`config: ${relativePath(jobForgeFactsConfigPath(PROJECT_DIR))}`);
+  console.log(formatConfigSummary(config));
+}
+
+function relativePath(path) {
+  return relative(PROJECT_DIR, path) || '.';
+}

package/scripts/redact.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, isAbsolute, relative, resolve } from 'path';
+import {
+  formatConfigSummary,
+  formatScanResult,
+  loadRedactConfig,
+  parseJson,
+  redactText,
+  scanSources,
+} from '@razroo/iso-redact';
+import { PROJECT_DIR } from '../tracker-lib.mjs';
+import {
+  jobForgeRedactConfigPath,
+  readJobForgeRedactConfig,
+} from '../lib/jobforge-redact.mjs';
+
+const USAGE = `job-forge redact - deterministic local redaction for exports
+
+Usage:
+  job-forge redact:scan   [--input <file> ...] [--stdin] [--config <file>] [--json]
+  job-forge redact:verify [--input <file> ...] [--stdin] [--config <file>] [--json]
+  job-forge redact:apply  (--input <file> | --stdin) [--output <file>] [--config <file>] [--json]
+  job-forge redact:explain [--config <file>] [--json]
+  job-forge redact:path
+
+Default policy is templates/redact.json. Findings never print matched values;
+previews are redacted length markers. Use apply to write a sanitized copy
+before exporting traces, prompts, reports, or fixture text.`;
+
+const [cmd = 'help', ...rawArgs] = process.argv.slice(2);
+const opts = parseArgs(rawArgs);
+
+if (opts.help || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(USAGE);
+  process.exit(0);
+}
+
+try {
+  if (cmd === 'path') {
+    console.log(configPath(opts));
+  } else if (cmd === 'scan' || cmd === 'verify') {
+    scan(cmd, opts);
+  } else if (cmd === 'apply') {
+    apply(opts);
+  } else if (cmd === 'explain') {
+    explain(opts);
+  } else {
+    console.error(`unknown redact command "${cmd}"\n`);
+    console.error(USAGE);
+    process.exit(2);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+
+function parseArgs(args) {
+  const opts = {
+    inputs: [],
+    stdin: false,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      opts.json = true;
+    } else if (arg === '--input' || arg === '-i') {
+      opts.inputs.push(valueAfter(args, ++i, arg));
+    } else if (arg.startsWith('--input=')) {
+      opts.inputs.push(arg.slice('--input='.length));
+    } else if (arg === '--stdin') {
+      opts.stdin = true;
+    } else if (arg === '--output' || arg === '-o') {
+      opts.output = valueAfter(args, ++i, arg);
+    } else if (arg.startsWith('--output=')) {
+      opts.output = arg.slice('--output='.length);
+    } else if (arg === '--config' || arg === '-c') {
+      opts.config = valueAfter(args, ++i, arg);
+    } else if (arg.startsWith('--config=')) {
+      opts.config = arg.slice('--config='.length);
+    } else if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else if (arg.startsWith('--')) {
+      throw new Error(`unknown flag "${arg}"`);
+    } else {
+      opts.inputs.push(arg);
+    }
+  }
+
+  return opts;
+}
+
+function valueAfter(values, index, flag) {
+  const value = values[index];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function scan(mode, opts) {
+  const sources = readSources(opts);
+  if (sources.length === 0) throw new Error(`${mode} requires at least one --input or --stdin source`);
+  const result = scanSources(readConfig(opts), sources);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatScanResult(result, mode));
+  }
+  if (mode === 'verify' && !result.ok) process.exit(1);
+}
+
+function apply(opts) {
+  const sources = readSources(opts);
+  if (sources.length !== 1) throw new Error('apply requires exactly one --input or --stdin source');
+  const source = sources[0];
+  const result = redactText(readConfig(opts), source.text, { source: source.name });
+  if (opts.output) {
+    const output = resolveOutputPath(opts.output);
+    mkdirSync(dirname(output), { recursive: true });
+    writeFileSync(output, result.text, 'utf8');
+    if (opts.json) {
+      console.log(JSON.stringify({ ...result, text: undefined, output }, null, 2));
+    } else {
+      console.log(`iso-redact: wrote ${relativePath(output)} (${result.findings.length} finding(s) redacted)`);
+    }
+  } else if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    process.stdout.write(result.text);
+  }
+}
+
+function explain(opts) {
+  const config = readConfig(opts);
+  if (opts.json) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  console.log(`config: ${relativePath(configPath(opts))}`);
+  console.log(formatConfigSummary(config));
+}
+
+function readSources(opts) {
+  const sources = opts.inputs.map((input) => {
+    const path = resolveInputPath(input);
+    return {
+      name: relativePath(path),
+      text: readFileSync(path, 'utf8'),
+    };
+  });
+  if (opts.stdin) sources.push({ name: '<stdin>', text: readFileSync(0, 'utf8') });
+  return sources;
+}
+
+function readConfig(opts) {
+  if (opts.config) {
+    const path = resolveInputPath(opts.config);
+    return loadRedactConfig(parseJson(readFileSync(path, 'utf8'), path));
+  }
+  return readJobForgeRedactConfig(PROJECT_DIR);
+}
+
+function configPath(opts) {
+  return opts.config ? resolveInputPath(opts.config) : jobForgeRedactConfigPath(PROJECT_DIR);
+}
+
+function resolveInputPath(path) {
+  return isAbsolute(path) ? path : resolve(PROJECT_DIR, path);
+}
+
+function resolveOutputPath(path) {
+  return isAbsolute(path) ? path : resolve(PROJECT_DIR, path);
+}
+
+function relativePath(path) {
+  return relative(PROJECT_DIR, path) || '.';
+}