job-forge 2.14.33 → 2.14.34

package/lib/jobforge-lineage.mjs

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
+import {
+  checkLineage,
+  emptyLineageGraph,
+  loadLineageGraph,
+  parseJson,
+  recordLineage,
+  verifyLineageGraph,
+} from '@razroo/iso-lineage';
+
+export const LINEAGE_FILE = '.jobforge-lineage.json';
+
+export function resolveProjectDir(projectDir = process.env.JOB_FORGE_PROJECT || process.cwd()) {
+  return projectDir;
+}
+
+export function jobForgeLineagePath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_LINEAGE || join(projectDir, LINEAGE_FILE);
+}
+
+export function lineageExists(projectDir = resolveProjectDir()) {
+  return existsSync(jobForgeLineagePath(projectDir));
+}
+
+export function readJobForgeLineage(projectDir = resolveProjectDir()) {
+  const path = jobForgeLineagePath(projectDir);
+  return loadLineageGraph(parseJson(readFileSync(path, 'utf8'), path));
+}
+
+export function readJobForgeLineageOrEmpty(projectDir = resolveProjectDir()) {
+  return lineageExists(projectDir) ? readJobForgeLineage(projectDir) : emptyLineageGraph();
+}
+
+export function writeJobForgeLineage(graph, options = {}, projectDir = resolveProjectDir()) {
+  const out = options.out || jobForgeLineagePath(projectDir);
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, `${JSON.stringify(graph, null, 2)}\n`, 'utf8');
+  return out;
+}
+
+export function recordJobForgeLineage(options = {}, projectDir = resolveProjectDir()) {
+  const graph = options.graph || readJobForgeLineageOrEmpty(projectDir);
+  const updated = recordLineage(graph, {
+    root: projectDir,
+    artifact: required(options.artifact, '--artifact'),
+    inputs: options.inputs || [],
+    optionalInputs: options.optionalInputs || [],
+    ...(options.kind ? { kind: options.kind } : {}),
+    ...(options.command ? { command: options.command } : {}),
+    ...(options.now ? { now: options.now } : {}),
+    ...(options.metadata ? { metadata: options.metadata } : {}),
+  });
+  const out = writeJobForgeLineage(updated, { out: options.out }, projectDir);
+  const artifact = storedPath(projectDir, options.artifact);
+  const record = updated.records.find((item) => item.artifact.path === artifact);
+  if (!record) throw new Error(`${artifact} was not recorded`);
+  return { graph: updated, record, out };
+}
+
+export function checkJobForgeLineage(options = {}, projectDir = resolveProjectDir()) {
+  const graph = options.graph || readJobForgeLineage(projectDir);
+  return checkLineage(graph, {
+    root: projectDir,
+    ...(options.artifact ? { artifact: options.artifact } : {}),
+  });
+}
+
+export function staleJobForgeLineage(options = {}, projectDir = resolveProjectDir()) {
+  return checkJobForgeLineage(options, projectDir);
+}
+
+export function verifyJobForgeLineage(options = {}, projectDir = resolveProjectDir()) {
+  const graph = options.graph || readJobForgeLineage(projectDir);
+  return verifyLineageGraph(graph);
+}
+
+export function jobForgeLineageSummary(projectDir = resolveProjectDir()) {
+  if (!lineageExists(projectDir)) {
+    return {
+      path: jobForgeLineagePath(projectDir),
+      exists: false,
+      records: 0,
+      current: 0,
+      stale: 0,
+      missing: 0,
+    };
+  }
+  const graph = readJobForgeLineage(projectDir);
+  const result = checkJobForgeLineage({ graph }, projectDir);
+  return {
+    path: jobForgeLineagePath(projectDir),
+    exists: true,
+    id: graph.id,
+    records: graph.records.length,
+    current: result.current,
+    stale: result.stale,
+    missing: result.missing,
+    ok: result.ok,
+  };
+}
+
+export function normalizeJobForgeLineageArtifact(projectDir = resolveProjectDir(), artifact = '') {
+  return storedPath(projectDir, artifact);
+}
+
+function required(value, flag) {
+  if (!value) throw new Error(`lineage:record requires ${flag}`);
+  return value;
+}
+
+function storedPath(root, path) {
+  const absRoot = resolve(root);
+  const abs = resolve(absRoot, path);
+  const rel = relative(absRoot, abs);
+  if (rel && !rel.startsWith('..') && !isAbsolute(rel)) return normalizePath(rel);
+  return normalizePath(abs);
+}
+
+function normalizePath(path) {
+  return path.split(sep).join('/');
+}

package/lib/jobforge-prioritize.mjs

@@ -0,0 +1,294 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import {
+  checkPrioritize,
+  loadPrioritizeConfig,
+  parseJson,
+  prioritize,
+  selectPrioritized,
+  verifyPrioritizeResult,
+} from '@razroo/iso-prioritize';
+import { ensureJobForgeFacts } from './jobforge-facts.mjs';
+import { dueJobForgeTimeline } from './jobforge-timeline.mjs';
+
+export const PRIORITIZE_CONFIG_FILE = 'templates/prioritize.json';
+export const PRIORITIZE_FILE = '.jobforge-prioritize.json';
+export const PRIORITIZE_ITEMS_FILE = '.jobforge-prioritize-items.json';
+
+export function resolveProjectDir(projectDir = process.env.JOB_FORGE_PROJECT || process.cwd()) {
+  return projectDir;
+}
+
+export function jobForgePrioritizeConfigPath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_PRIORITIZE_CONFIG || join(projectDir, PRIORITIZE_CONFIG_FILE);
+}
+
+export function jobForgePrioritizePath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_PRIORITIZE || join(projectDir, PRIORITIZE_FILE);
+}
+
+export function jobForgePrioritizeItemsPath(projectDir = resolveProjectDir()) {
+  return process.env.JOB_FORGE_PRIORITIZE_ITEMS || join(projectDir, PRIORITIZE_ITEMS_FILE);
+}
+
+export function prioritizeExists(projectDir = resolveProjectDir()) {
+  return existsSync(jobForgePrioritizePath(projectDir));
+}
+
+export function readJobForgePrioritizeConfig(projectDir = resolveProjectDir()) {
+  const path = jobForgePrioritizeConfigPath(projectDir);
+  return loadPrioritizeConfig(parseJson(readFileSync(path, 'utf8'), path));
+}
+
+export function readJobForgePrioritize(projectDir = resolveProjectDir()) {
+  const path = jobForgePrioritizePath(projectDir);
+  return parseJson(readFileSync(path, 'utf8'), path);
+}
+
+export function readJobForgePrioritizeItems(projectDir = resolveProjectDir()) {
+  const path = jobForgePrioritizeItemsPath(projectDir);
+  return parseJson(readFileSync(path, 'utf8'), path);
+}
+
+export function buildJobForgePrioritizeItems(options = {}, projectDir = resolveProjectDir()) {
+  const factSet = options.facts || ensureJobForgeFacts({ rebuild: options.rebuild !== false }, projectDir);
+  const items = [];
+
+  for (const fact of factSet.facts || []) {
+    const candidate = candidateItem(fact);
+    if (candidate) items.push(candidate);
+
+    const evaluated = evaluatedTrackerItem(fact);
+    if (evaluated) items.push(evaluated);
+  }
+
+  for (const item of dueJobForgeTimeline({ now: options.now }, projectDir).items || []) {
+    const followup = timelineItem(item);
+    if (followup) items.push(followup);
+  }
+
+  return { items: dedupeItems(items) };
+}
+
+export function rankJobForgePrioritize(options = {}, projectDir = resolveProjectDir()) {
+  const config = options.config || readJobForgePrioritizeConfig(projectDir);
+  const items = options.items || buildJobForgePrioritizeItems(options, projectDir);
+  return prioritize(config, items, { profile: options.profile, limit: options.limit });
+}
+
+export function selectJobForgePrioritize(options = {}, projectDir = resolveProjectDir()) {
+  return selectPrioritized(rankJobForgePrioritize(options, projectDir));
+}
+
+export function checkJobForgePrioritize(options = {}, projectDir = resolveProjectDir()) {
+  const config = options.config || readJobForgePrioritizeConfig(projectDir);
+  const items = options.items || buildJobForgePrioritizeItems(options, projectDir);
+  return checkPrioritize(config, items, {
+    profile: options.profile,
+    limit: options.limit,
+    minSelected: options.minSelected,
+    failOn: options.failOn,
+  });
+}
+
+export function writeJobForgePrioritize(result, options = {}, projectDir = resolveProjectDir()) {
+  const out = options.out || jobForgePrioritizePath(projectDir);
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+  return out;
+}
+
+export function writeJobForgePrioritizeItems(items, options = {}, projectDir = resolveProjectDir()) {
+  const out = options.out || jobForgePrioritizeItemsPath(projectDir);
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, `${JSON.stringify(items, null, 2)}\n`, 'utf8');
+  return out;
+}
+
+export function verifyJobForgePrioritize(options = {}, projectDir = resolveProjectDir()) {
+  const result = options.result || readJobForgePrioritize(projectDir);
+  return verifyPrioritizeResult(result);
+}
+
+export function jobForgePrioritizeSummary(projectDir = resolveProjectDir()) {
+  if (!prioritizeExists(projectDir)) {
+    return {
+      path: jobForgePrioritizePath(projectDir),
+      itemsPath: jobForgePrioritizeItemsPath(projectDir),
+      config: jobForgePrioritizeConfigPath(projectDir),
+      exists: false,
+      items: 0,
+      selected: 0,
+      candidate: 0,
+      skipped: 0,
+      blocked: 0,
+    };
+  }
+
+  const result = readJobForgePrioritize(projectDir);
+  return {
+    path: jobForgePrioritizePath(projectDir),
+    itemsPath: jobForgePrioritizeItemsPath(projectDir),
+    config: jobForgePrioritizeConfigPath(projectDir),
+    exists: true,
+    items: result.stats?.total || 0,
+    selected: result.stats?.selected || 0,
+    candidate: result.stats?.candidate || 0,
+    skipped: result.stats?.skipped || 0,
+    blocked: result.stats?.blocked || 0,
+    id: result.id,
+    profile: result.profile,
+  };
+}
+
+function candidateItem(fact) {
+  if (fact.fact !== 'candidate.ready') return null;
+  const fields = fact.fields || {};
+  const company = stringField(fields.company);
+  const role = stringField(fields.role);
+  const score = parseScore(fields.score);
+
+  return compactItem({
+    id: `candidate-${slug(fields.id || fact.key || fact.id)}`,
+    key: fact.key,
+    type: 'apply',
+    title: title(company, role, 'apply'),
+    tags: ['apply', 'candidate'],
+    data: compactObject({
+      company,
+      role,
+      score,
+      urgency: score >= 4 ? 8 : 6,
+      ageDays: 0,
+      sourceQuality: sourceQuality(fact, score),
+      status: fields.gateStatus || 'Evaluated',
+      gateStatus: fields.gateStatus,
+      locationStatus: fields.locationStatus,
+      url: fields.url,
+    }),
+    source: fact.source,
+  });
+}
+
+function evaluatedTrackerItem(fact) {
+  if (fact.fact !== 'application.status') return null;
+  const fields = fact.fields || {};
+  const status = stringField(fields.status || fact.value);
+  if (status !== 'Evaluated') return null;
+  const company = stringField(fields.company);
+  const role = stringField(fields.role);
+  const score = parseScore(fields.score);
+
+  return compactItem({
+    id: `evaluated-${slug(fields.num || fact.key || fact.id)}`,
+    key: fact.key,
+    type: 'apply',
+    title: title(company, role, 'apply'),
+    tags: ['apply', 'tracker'],
+    data: compactObject({
+      company,
+      role,
+      score,
+      urgency: score >= 4 ? 8 : 5,
+      ageDays: ageDays(fields.date),
+      sourceQuality: sourceQuality(fact, score),
+      status,
+      report: fields.report,
+      pdf: fields.pdf,
+    }),
+    source: fact.source,
+  });
+}
+
+function timelineItem(item) {
+  const data = item.event?.data || {};
+  const company = stringField(data.company);
+  const role = stringField(data.role);
+  const score = parseScore(data.score);
+
+  return compactItem({
+    id: `timeline-${slug(item.id)}`,
+    key: item.key,
+    type: 'followup',
+    title: title(company, role, item.action || 'follow-up'),
+    tags: ['followup', item.state],
+    data: compactObject({
+      company,
+      role,
+      score,
+      urgency: item.state === 'overdue' ? 10 : 8,
+      ageDays: ageDays(item.event?.at),
+      sourceQuality: sourceQuality(item.event, score),
+      status: data.status,
+      timelineState: item.state,
+      action: item.action,
+      rule: item.rule,
+    }),
+    source: item.event?.source,
+  });
+}
+
+function dedupeItems(items) {
+  const byId = new Map();
+  for (const item of items) {
+    const existing = byId.get(item.id);
+    if (!existing || priorityValue(item) > priorityValue(existing)) byId.set(item.id, item);
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function priorityValue(item) {
+  return Number(item.data?.score || 0) * 100 +
+    Number(item.data?.urgency || 0) * 10 +
+    Number(item.data?.sourceQuality || 0);
+}
+
+function parseScore(value) {
+  const match = String(value || '').match(/([0-9]+(?:\.[0-9]+)?)(?:\s*\/\s*5)?/);
+  if (!match) return 0;
+  return Math.max(0, Math.min(5, Number(match[1])));
+}
+
+function ageDays(value) {
+  const text = String(value || '').trim();
+  if (!text) return 0;
+  const parsed = new Date(text);
+  if (Number.isNaN(parsed.getTime())) return 0;
+  return Math.max(0, Math.floor((Date.now() - parsed.getTime()) / 86400000));
+}
+
+function sourceQuality(sourceLike, score) {
+  if (sourceLike?.source?.path && score > 0) return 1;
+  return score > 0 ? 0.8 : 0;
+}
+
+function stringField(value) {
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function title(company, role, suffix) {
+  const base = [company, role].filter(Boolean).join(' - ');
+  return suffix && base ? `${base} ${suffix}` : base || suffix || 'JobForge item';
+}
+
+function slug(value) {
+  return String(value || 'item')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80) || 'item';
+}
+
+function compactItem(item) {
+  return {
+    ...item,
+    tags: (item.tags || []).filter(Boolean),
+    ...(item.source ? { source: item.source } : {}),
+  };
+}
+
+function compactObject(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ''),
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-forge",
-  "version": "2.14.33",
+  "version": "2.14.34",
   "description": "AI-powered job search pipeline built on opencode",
   "type": "module",
   "bin": {
@@ -85,6 +85,20 @@
     "timeline:check": "node bin/job-forge.mjs timeline:check",
     "timeline:verify": "node bin/job-forge.mjs timeline:verify",
     "timeline:explain": "node bin/job-forge.mjs timeline:explain",
+    "prioritize:status": "node bin/job-forge.mjs prioritize:status",
+    "prioritize:items": "node bin/job-forge.mjs prioritize:items",
+    "prioritize:build": "node bin/job-forge.mjs prioritize:build",
+    "prioritize:rank": "node bin/job-forge.mjs prioritize:rank",
+    "prioritize:select": "node bin/job-forge.mjs prioritize:select",
+    "prioritize:check": "node bin/job-forge.mjs prioritize:check",
+    "prioritize:verify": "node bin/job-forge.mjs prioritize:verify",
+    "prioritize:explain": "node bin/job-forge.mjs prioritize:explain",
+    "lineage:status": "node bin/job-forge.mjs lineage:status",
+    "lineage:record": "node bin/job-forge.mjs lineage:record",
+    "lineage:check": "node bin/job-forge.mjs lineage:check",
+    "lineage:stale": "node bin/job-forge.mjs lineage:stale",
+    "lineage:verify": "node bin/job-forge.mjs lineage:verify",
+    "lineage:explain": "node bin/job-forge.mjs lineage: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",
@@ -168,10 +182,12 @@
     "@razroo/iso-guard": "^0.1.0",
     "@razroo/iso-index": "^0.1.0",
     "@razroo/iso-ledger": "^0.1.0",
+    "@razroo/iso-lineage": "^0.1.0",
     "@razroo/iso-migrate": "^0.1.0",
     "@razroo/iso-orchestrator": "^0.1.0",
     "@razroo/iso-postflight": "^0.1.0",
     "@razroo/iso-preflight": "^0.1.0",
+    "@razroo/iso-prioritize": "^0.1.0",
     "@razroo/iso-redact": "^0.1.0",
     "@razroo/iso-score": "^0.1.0",
     "@razroo/iso-timeline": "^0.1.0",

package/scripts/check-iso-smoke.mjs

@@ -21,6 +21,8 @@ const checks = [
   ["H7 distrusts subagent prose", () => every(files.instructions, ["must originate from a file", "not from prior subagent prose"])],
   ["score policy points to local helper", () => every(files.instructions, ["[D19]", "templates/score.json", "npx job-forge score:check", "npx job-forge score:gate"])],
   ["timeline policy points to local helper", () => every(files.instructions, ["[D20]", "templates/timeline.json", "npx job-forge timeline:due", "npx job-forge timeline:check --fail-on overdue"])],
+  ["prioritize policy points to local helper", () => every(files.instructions, ["[D21]", "templates/prioritize.json", "npx job-forge prioritize:build", "npx job-forge prioritize:select --limit N"])],
+  ["lineage policy points to local helper", () => every(files.instructions, ["[D22]", ".jobforge-lineage.json", "npx job-forge lineage:record", "npx job-forge lineage:check"])],
   ["shared prompt points to on-demand references", () => every(files.instructions, ["modes/{mode}.md", "modes/reference-setup.md", "modes/reference-portals.md", "modes/reference-geometra.md"])],
   ["apply mode owns high-stakes upgrade", () => every(files.apply, ["[D8]", "@general-paid", "4.0/5", "high-stakes"])],
   ["apply mode blocks provider auto-downgrade", () => every(files.apply, ["[D9]", "do not auto-downgrade", "inspect telemetry before retrying"])],