job-forge 2.14.32 → 2.14.34

package/scripts/prioritize.mjs

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import { isAbsolute, relative, resolve } from 'path';
+import {
+  formatCheckResult,
+  formatConfigSummary,
+  formatPrioritizeResult,
+  formatVerifyResult,
+  loadPrioritizeItems,
+  parseJson,
+} from '@razroo/iso-prioritize';
+import { PROJECT_DIR } from '../tracker-lib.mjs';
+import {
+  buildJobForgePrioritizeItems,
+  checkJobForgePrioritize,
+  jobForgePrioritizeConfigPath,
+  jobForgePrioritizeItemsPath,
+  jobForgePrioritizePath,
+  jobForgePrioritizeSummary,
+  prioritizeExists,
+  rankJobForgePrioritize,
+  readJobForgePrioritizeConfig,
+  selectJobForgePrioritize,
+  verifyJobForgePrioritize,
+  writeJobForgePrioritize,
+  writeJobForgePrioritizeItems,
+} from '../lib/jobforge-prioritize.mjs';
+
+const USAGE = `job-forge prioritize - deterministic next-action ranking
+
+Usage:
+  job-forge prioritize:status [--json]
+  job-forge prioritize:items [--now <iso>] [--out <file>] [--json]
+  job-forge prioritize:build [--now <iso>] [--profile <name>] [--limit N] [--out <file>] [--items-out <file>] [--json]
+  job-forge prioritize:rank [--items <file>] [--profile <name>] [--limit N] [--json]
+  job-forge prioritize:select [--items <file>] [--profile <name>] [--limit N] [--json]
+  job-forge prioritize:check [--items <file>] [--profile <name>] [--limit N] [--min-selected N] [--fail-on blocked|skipped,blocked|none] [--json]
+  job-forge prioritize:verify [--json]
+  job-forge prioritize:explain [--profile <name>] [--json]
+  job-forge prioritize:path [--config|--items]
+
+Default policy is templates/prioritize.json. The generated queue is local
+project state (.jobforge-prioritize.json), derived from source-backed facts and
+due timeline items.`;
+
+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') {
+    path(opts);
+  } else if (cmd === 'status') {
+    status(opts);
+  } else if (cmd === 'items') {
+    items(opts);
+  } else if (cmd === 'build') {
+    build(opts);
+  } else if (cmd === 'rank') {
+    rank(opts);
+  } else if (cmd === 'select') {
+    select(opts);
+  } else if (cmd === 'check') {
+    check(opts);
+  } else if (cmd === 'verify') {
+    verify(opts);
+  } else if (cmd === 'explain') {
+    explain(opts);
+  } else {
+    console.error(`unknown prioritize 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,
+  };
+
+  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 === '--profile') {
+      opts.profile = valueAfter(args, ++i, '--profile');
+    } else if (arg.startsWith('--profile=')) {
+      opts.profile = arg.slice('--profile='.length);
+    } else if (arg === '--limit') {
+      opts.limit = parsePositiveInteger(valueAfter(args, ++i, '--limit'), '--limit');
+    } else if (arg.startsWith('--limit=')) {
+      opts.limit = parsePositiveInteger(arg.slice('--limit='.length), '--limit');
+    } else if (arg === '--min-selected') {
+      opts.minSelected = parseNonNegativeInteger(valueAfter(args, ++i, '--min-selected'), '--min-selected');
+    } else if (arg.startsWith('--min-selected=')) {
+      opts.minSelected = parseNonNegativeInteger(arg.slice('--min-selected='.length), '--min-selected');
+    } else if (arg === '--fail-on') {
+      opts.failOn = parseFailOn(valueAfter(args, ++i, '--fail-on'));
+    } else if (arg.startsWith('--fail-on=')) {
+      opts.failOn = parseFailOn(arg.slice('--fail-on='.length));
+    } else if (arg === '--now') {
+      opts.now = valueAfter(args, ++i, '--now');
+    } else if (arg.startsWith('--now=')) {
+      opts.now = arg.slice('--now='.length);
+    } else if (arg === '--items') {
+      if (!args[i + 1] || args[i + 1].startsWith('--')) {
+        opts.itemsPath = true;
+      } else {
+        opts.items = valueAfter(args, ++i, '--items');
+      }
+    } else if (arg.startsWith('--items=')) {
+      opts.items = arg.slice('--items='.length);
+    } else if (arg === '--out') {
+      opts.out = resolveInputPath(valueAfter(args, ++i, '--out'));
+    } else if (arg.startsWith('--out=')) {
+      opts.out = resolveInputPath(arg.slice('--out='.length));
+    } else if (arg === '--items-out') {
+      opts.itemsOut = resolveInputPath(valueAfter(args, ++i, '--items-out'));
+    } else if (arg.startsWith('--items-out=')) {
+      opts.itemsOut = resolveInputPath(arg.slice('--items-out='.length));
+    } else if (arg === '--config') {
+      opts.configPath = true;
+    } else if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else {
+      throw new Error(`unknown flag "${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 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 parseNonNegativeInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) throw new Error(`${flag} must be a non-negative integer`);
+  return parsed;
+}
+
+function parseFailOn(value) {
+  if (value === 'none') return 'none';
+  return value.split(',').map((item) => item.trim()).filter(Boolean);
+}
+
+function path(opts) {
+  if (opts.configPath) {
+    console.log(jobForgePrioritizeConfigPath(PROJECT_DIR));
+  } else if (opts.itemsPath) {
+    console.log(jobForgePrioritizeItemsPath(PROJECT_DIR));
+  } else {
+    console.log(jobForgePrioritizePath(PROJECT_DIR));
+  }
+}
+
+function status(opts) {
+  const summary = jobForgePrioritizeSummary(PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  if (!summary.exists) {
+    console.log(`prioritize: missing (${relativePath(summary.path)})`);
+    console.log('run: job-forge prioritize:build');
+    return;
+  }
+  const result = verifyJobForgePrioritize({}, PROJECT_DIR);
+  console.log(`prioritize: ${relativePath(summary.path)}`);
+  console.log(`items:      ${relativePath(summary.itemsPath)}`);
+  console.log(`profile:    ${summary.profile}`);
+  console.log(`total:      ${summary.items}`);
+  console.log(`selected:   ${summary.selected}`);
+  console.log(`candidate:  ${summary.candidate}`);
+  console.log(`skipped:    ${summary.skipped}`);
+  console.log(`blocked:    ${summary.blocked}`);
+  console.log(`verify:     ${result.ok ? 'PASS' : 'FAIL'} (${result.errors} errors, ${result.warnings} warnings)`);
+}
+
+function items(opts) {
+  const input = buildJobForgePrioritizeItems({ now: opts.now, rebuild: opts.rebuild }, PROJECT_DIR);
+  if (opts.out) writeJobForgePrioritizeItems(input, { out: opts.out }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(input, null, 2));
+    return;
+  }
+  if (opts.out) console.log(`items: wrote ${relativePath(opts.out)}`);
+  console.log(`items: ${input.items.length}`);
+}
+
+function build(opts) {
+  const input = readItems(opts) || buildJobForgePrioritizeItems({ now: opts.now, rebuild: opts.rebuild }, PROJECT_DIR);
+  const result = rankJobForgePrioritize({
+    items: input,
+    profile: opts.profile,
+    limit: opts.limit,
+  }, PROJECT_DIR);
+  const itemsOut = writeJobForgePrioritizeItems(input, { out: opts.itemsOut }, PROJECT_DIR);
+  const out = writeJobForgePrioritize(result, { out: opts.out }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify({ out, itemsOut, result }, null, 2));
+    return;
+  }
+  console.log(`prioritize: wrote ${relativePath(out)}`);
+  console.log(`items:      wrote ${relativePath(itemsOut)}`);
+  console.log(formatPrioritizeResult(result));
+}
+
+function rank(opts) {
+  const result = rankJobForgePrioritize({
+    items: readItems(opts),
+    profile: opts.profile,
+    limit: opts.limit,
+    now: opts.now,
+    rebuild: opts.rebuild,
+  }, PROJECT_DIR);
+  if (opts.out) writeJobForgePrioritize(result, { out: opts.out }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatPrioritizeResult(result));
+}
+
+function select(opts) {
+  const result = selectJobForgePrioritize({
+    items: readItems(opts),
+    profile: opts.profile,
+    limit: opts.limit,
+    now: opts.now,
+    rebuild: opts.rebuild,
+  }, PROJECT_DIR);
+  if (opts.out) writeJobForgePrioritize(result, { out: opts.out }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatPrioritizeResult(result));
+}
+
+function check(opts) {
+  const result = checkJobForgePrioritize({
+    items: readItems(opts),
+    profile: opts.profile,
+    limit: opts.limit,
+    minSelected: opts.minSelected,
+    failOn: opts.failOn,
+    now: opts.now,
+    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 verify(opts) {
+  if (!prioritizeExists(PROJECT_DIR)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true, missing: true, path: jobForgePrioritizePath(PROJECT_DIR) }, null, 2));
+    } else {
+      console.log(`prioritize: missing (${relativePath(jobForgePrioritizePath(PROJECT_DIR))})`);
+    }
+    return;
+  }
+  const result = verifyJobForgePrioritize({}, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatVerifyResult(result));
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+function explain(opts) {
+  const config = readJobForgePrioritizeConfig(PROJECT_DIR);
+  if (opts.json) {
+    const value = opts.profile
+      ? { ...config, profiles: config.profiles.filter((profile) => profile.name === opts.profile) }
+      : config;
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  console.log(`config: ${relativePath(jobForgePrioritizeConfigPath(PROJECT_DIR))}`);
+  console.log(formatConfigSummary(config, opts.profile));
+}
+
+function readItems(opts) {
+  if (!opts.items) return undefined;
+  const path = resolveInputPath(opts.items);
+  return { items: loadPrioritizeItems(parseJson(readFileSync(path, 'utf8'), path)) };
+}
+
+function resolveInputPath(path) {
+  return isAbsolute(path) ? path : resolve(PROJECT_DIR, path);
+}
+
+function relativePath(path) {
+  return relative(PROJECT_DIR, path) || '.';
+}

package/scripts/timeline.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+import { writeFileSync } from 'fs';
+import { isAbsolute, relative, resolve } from 'path';
+import {
+  formatCheckResult,
+  formatConfigSummary,
+  formatTimelineResult,
+  formatVerifyResult,
+} from '@razroo/iso-timeline';
+import { PROJECT_DIR } from '../tracker-lib.mjs';
+import {
+  buildJobForgeTimeline,
+  buildJobForgeTimelineEvents,
+  checkJobForgeTimeline,
+  dueJobForgeTimeline,
+  jobForgeTimelineConfigPath,
+  jobForgeTimelineEventsPath,
+  jobForgeTimelinePath,
+  jobForgeTimelineSummary,
+  planJobForgeTimeline,
+  readJobForgeTimelineConfig,
+  timelineExists,
+  verifyJobForgeTimeline,
+} from '../lib/jobforge-timeline.mjs';
+
+const USAGE = `job-forge timeline - deterministic follow-up and next-action planning
+
+Usage:
+  job-forge timeline:status [--json]
+  job-forge timeline:build [--now <iso>] [--json]
+  job-forge timeline:plan [--now <iso>] [--out <file>] [--json]
+  job-forge timeline:due [--now <iso>] [--json]
+  job-forge timeline:check [--now <iso>] [--fail-on overdue|due|none] [--json]
+  job-forge timeline:verify [--json]
+  job-forge timeline:explain [--json]
+  job-forge timeline:path [--config|--events]
+
+Default policy is templates/timeline.json. Tracker day files and dated pipeline
+items are converted into .jobforge-timeline-events.jsonl; the plan is written
+to .jobforge-timeline.json by timeline:build. This is local project state, not
+an MCP and not prompt context.`;
+
+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') {
+    path(opts);
+  } else if (cmd === 'status') {
+    status(opts);
+  } else if (cmd === 'build') {
+    build(opts);
+  } else if (cmd === 'plan') {
+    plan(opts);
+  } else if (cmd === 'due') {
+    due(opts);
+  } else if (cmd === 'check') {
+    check(opts);
+  } else if (cmd === 'verify') {
+    verify(opts);
+  } else if (cmd === 'explain') {
+    explain(opts);
+  } else {
+    console.error(`unknown timeline 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,
+    failOn: undefined,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      opts.json = true;
+    } else if (arg === '--now') {
+      opts.now = valueAfter(args, ++i, '--now');
+    } else if (arg.startsWith('--now=')) {
+      opts.now = arg.slice('--now='.length);
+    } else if (arg === '--fail-on') {
+      opts.failOn = valueAfter(args, ++i, '--fail-on');
+    } else if (arg.startsWith('--fail-on=')) {
+      opts.failOn = arg.slice('--fail-on='.length);
+    } else if (arg === '--out') {
+      opts.out = valueAfter(args, ++i, '--out');
+    } else if (arg.startsWith('--out=')) {
+      opts.out = arg.slice('--out='.length);
+    } else if (arg === '--config') {
+      opts.configPath = true;
+    } else if (arg === '--events') {
+      opts.eventsPath = true;
+    } else if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else {
+      throw new Error(`unknown flag "${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 path(opts) {
+  if (opts.configPath) {
+    console.log(jobForgeTimelineConfigPath(PROJECT_DIR));
+  } else if (opts.eventsPath) {
+    console.log(jobForgeTimelineEventsPath(PROJECT_DIR));
+  } else {
+    console.log(jobForgeTimelinePath(PROJECT_DIR));
+  }
+}
+
+function status(opts) {
+  const summary = jobForgeTimelineSummary(PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  if (!summary.exists) {
+    console.log(`timeline: missing (${relativePath(summary.path)})`);
+    console.log('run: job-forge timeline:build');
+    return;
+  }
+  const verifyResult = verifyJobForgeTimeline({}, PROJECT_DIR);
+  console.log(`timeline: ${relativePath(summary.path)}`);
+  console.log(`events:   ${relativePath(summary.eventsPath)} (${summary.eventsExists ? 'present' : 'missing'})`);
+  console.log(`items:    ${summary.items}`);
+  console.log(`due:      ${summary.due}`);
+  console.log(`overdue:  ${summary.overdue}`);
+  console.log(`verify:   ${verifyResult.ok ? 'PASS' : 'FAIL'} (${verifyResult.errors} errors, ${verifyResult.warnings} warnings)`);
+}
+
+function build(opts) {
+  const result = buildJobForgeTimeline({ now: opts.now }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      out: result.out,
+      eventsOut: result.eventsOut,
+      events: result.events.length,
+      stats: result.result.stats,
+    }, null, 2));
+    return;
+  }
+  console.log(`timeline: wrote ${relativePath(result.out)}`);
+  console.log(`events:   wrote ${relativePath(result.eventsOut)} (${result.events.length} event(s))`);
+  console.log(formatTimelineResult(result.result));
+}
+
+function plan(opts) {
+  const result = planJobForgeTimeline({ now: opts.now }, PROJECT_DIR);
+  if (opts.out) writePlan(resolveInputPath(opts.out), result);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatTimelineResult(result));
+}
+
+function due(opts) {
+  const result = dueJobForgeTimeline({ now: opts.now }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatTimelineResult(result));
+  }
+}
+
+function check(opts) {
+  const result = checkJobForgeTimeline({ now: opts.now, failOn: opts.failOn }, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatCheckResult(result));
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+function verify(opts) {
+  if (!timelineExists(PROJECT_DIR)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true, missing: true, path: jobForgeTimelinePath(PROJECT_DIR) }, null, 2));
+    } else {
+      console.log(`timeline: missing (${relativePath(jobForgeTimelinePath(PROJECT_DIR))})`);
+    }
+    return;
+  }
+  const result = verifyJobForgeTimeline({}, PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatVerifyResult(result));
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+
+function explain(opts) {
+  const config = readJobForgeTimelineConfig(PROJECT_DIR);
+  if (opts.json) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  console.log(`config: ${relativePath(jobForgeTimelineConfigPath(PROJECT_DIR))}`);
+  console.log(formatConfigSummary(config));
+  const events = buildJobForgeTimelineEvents(PROJECT_DIR);
+  console.log(`events available now: ${events.length}`);
+}
+
+function resolveInputPath(path) {
+  return isAbsolute(path) ? path : resolve(PROJECT_DIR, path);
+}
+
+function relativePath(path) {
+  return relative(PROJECT_DIR, path) || '.';
+}
+
+function writePlan(path, result) {
+  writeFileSync(path, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+}

package/templates/migrations.json

@@ -56,6 +56,27 @@
             "postflight:status": "job-forge postflight:status",
             "postflight:check": "job-forge postflight:check",
             "postflight:explain": "job-forge postflight:explain",
+            "timeline:status": "job-forge timeline:status",
+            "timeline:build": "job-forge timeline:build",
+            "timeline:plan": "job-forge timeline:plan",
+            "timeline:due": "job-forge timeline:due",
+            "timeline:check": "job-forge timeline:check",
+            "timeline:verify": "job-forge timeline:verify",
+            "timeline:explain": "job-forge timeline:explain",
+            "prioritize:status": "job-forge prioritize:status",
+            "prioritize:items": "job-forge prioritize:items",
+            "prioritize:build": "job-forge prioritize:build",
+            "prioritize:rank": "job-forge prioritize:rank",
+            "prioritize:select": "job-forge prioritize:select",
+            "prioritize:check": "job-forge prioritize:check",
+            "prioritize:verify": "job-forge prioritize:verify",
+            "prioritize:explain": "job-forge prioritize:explain",
+            "lineage:status": "job-forge lineage:status",
+            "lineage:record": "job-forge lineage:record",
+            "lineage:check": "job-forge lineage:check",
+            "lineage:stale": "job-forge lineage:stale",
+            "lineage:verify": "job-forge lineage:verify",
+            "lineage:explain": "job-forge lineage:explain",
             "redact:scan": "job-forge redact:scan",
             "redact:verify": "job-forge redact:verify",
             "redact:apply": "job-forge redact:apply",
@@ -83,7 +104,13 @@
             ".jobforge-cache/",
             ".jobforge-index.json",
             ".jobforge-facts.json",
+            ".jobforge-timeline.json",
+            ".jobforge-timeline-events.jsonl",
+            ".jobforge-prioritize.json",
+            ".jobforge-prioritize-items.json",
+            ".jobforge-lineage.json",
             ".jobforge-redacted/",
+            "data/timeline-events.jsonl",
             "batch/preflight-candidates.json",
             "batch/preflight-plan.json",
             "batch/postflight-outcomes.json"