erdos-problems 0.1.13 → 0.2.1

package/src/commands/number-theory.js

@@ -0,0 +1,199 @@
+import { getProblem } from '../atlas/catalog.js';
+import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+function resolveNumberTheoryProblem(problemId) {
+  const resolvedId = problemId ?? readCurrentProblem();
+  if (!resolvedId) {
+    return { error: 'Missing problem id and no active problem is selected.' };
+  }
+
+  const problem = getProblem(resolvedId);
+  if (!problem) {
+    return { error: `Unknown problem: ${resolvedId}` };
+  }
+
+  if (problem.cluster !== 'number-theory') {
+    return { error: `Problem ${resolvedId} is not in the number-theory pack.` };
+  }
+
+  return { problem };
+}
+
+function parseArgs(args) {
+  const parsed = {
+    problemId: null,
+    asJson: false,
+  };
+
+  for (const token of args) {
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    if (!parsed.problemId) {
+      parsed.problemId = token;
+      continue;
+    }
+    return { error: `Unknown number-theory option: ${token}` };
+  }
+
+  return parsed;
+}
+
+function printStatus(snapshot) {
+  console.log(`${snapshot.displayName} number-theory harness`);
+  console.log(`Family role: ${snapshot.familyRole}`);
+  console.log(`Harness profile: ${snapshot.harnessProfile}`);
+  console.log(`Site status: ${snapshot.siteStatus}`);
+  console.log(`Archive mode: ${snapshot.archiveMode ?? '(none)'}`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  console.log(`Route breakthrough: ${snapshot.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${snapshot.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail}`);
+  console.log(`Checkpoint focus: ${snapshot.checkpointFocus ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
+  console.log(`Route packet present: ${snapshot.routePacketPresent ? 'yes' : 'no'}`);
+  if (snapshot.routePacket?.route_packet_id) {
+    console.log(`Route packet id: ${snapshot.routePacket.route_packet_id}`);
+  }
+  console.log(`Frontier note: ${snapshot.frontierNotePresent ? snapshot.frontierNotePath : '(missing)'}`);
+  console.log(`Route history: ${snapshot.routeHistoryPresent ? snapshot.routeHistoryPath : '(missing)'}`);
+  console.log(`Checkpoint template: ${snapshot.checkpointTemplatePresent ? snapshot.checkpointTemplatePath : '(missing)'}`);
+  console.log(`Report template: ${snapshot.reportTemplatePresent ? snapshot.reportTemplatePath : '(missing)'}`);
+  console.log(`Ops details present: ${snapshot.opsDetailsPresent ? 'yes' : 'no'}`);
+  console.log(`Active ticket: ${snapshot.activeTicketDetail?.ticket_id ?? '(none)'}`);
+  console.log(`Ready atoms: ${snapshot.readyAtomCount}`);
+  if (snapshot.firstReadyAtom) {
+    console.log(`First ready atom: ${snapshot.firstReadyAtom.atom_id} — ${snapshot.firstReadyAtom.title}`);
+  }
+}
+
+function printFrontier(snapshot) {
+  console.log(`${snapshot.displayName} number-theory frontier`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail}`);
+  console.log(`Checkpoint focus: ${snapshot.checkpointFocus ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
+  console.log(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
+  console.log(`Archive mode: ${snapshot.archiveMode ?? '(none)'}`);
+  console.log(`Frontier note: ${snapshot.frontierNotePresent ? snapshot.frontierNotePath : '(missing)'}`);
+  console.log(`Route history: ${snapshot.routeHistoryPresent ? snapshot.routeHistoryPath : '(missing)'}`);
+}
+
+function printRoutes(snapshot) {
+  console.log(`${snapshot.displayName} number-theory routes`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  if (!snapshot.opsDetails?.routes?.length) {
+    console.log('Routes: none recorded.');
+    return;
+  }
+  for (const route of snapshot.opsDetails.routes) {
+    const flags = [];
+    if (route.route_id === snapshot.activeRoute) {
+      flags.push('active');
+    }
+    if (route.status) {
+      flags.push(route.status);
+    }
+    console.log(`- ${route.route_id}${flags.length > 0 ? ` [${flags.join(', ')}]` : ''}`);
+    if (route.title) {
+      console.log(`  title: ${route.title}`);
+    }
+    if (route.summary) {
+      console.log(`  summary: ${route.summary}`);
+    }
+    if (route.why_now) {
+      console.log(`  why now: ${route.why_now}`);
+    }
+    if (route.next_move) {
+      console.log(`  next move: ${route.next_move}`);
+    }
+  }
+}
+
+function printTickets(snapshot) {
+  console.log(`${snapshot.displayName} number-theory tickets`);
+  if (!snapshot.opsDetails?.tickets?.length) {
+    console.log('Tickets: none recorded.');
+    return;
+  }
+  console.log(`Active ticket: ${snapshot.activeTicketDetail?.ticket_id ?? '(none)'}`);
+  for (const ticket of snapshot.opsDetails.tickets) {
+    const flags = [];
+    if (ticket.ticket_id === snapshot.activeTicketDetail?.ticket_id) {
+      flags.push('active');
+    }
+    if (ticket.status) {
+      flags.push(ticket.status);
+    }
+    console.log(`- ${ticket.ticket_id}${flags.length > 0 ? ` [${flags.join(', ')}]` : ''}`);
+    if (ticket.title) {
+      console.log(`  title: ${ticket.title}`);
+    }
+    if (ticket.summary) {
+      console.log(`  summary: ${ticket.summary}`);
+    }
+    if (ticket.current_blocker) {
+      console.log(`  blocker: ${ticket.current_blocker}`);
+    }
+    if (ticket.next_move) {
+      console.log(`  next move: ${ticket.next_move}`);
+    }
+  }
+}
+
+export function runNumberTheoryCommand(args) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos number-theory status [<id>] [--json]');
+    console.log('  erdos number-theory frontier [<id>] [--json]');
+    console.log('  erdos number-theory routes [<id>] [--json]');
+    console.log('  erdos number-theory tickets [<id>] [--json]');
+    return 0;
+  }
+
+  if (!['status', 'frontier', 'routes', 'tickets'].includes(subcommand)) {
+    console.error(`Unknown number-theory subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const parsed = parseArgs(rest);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+
+  const { problem, error } = resolveNumberTheoryProblem(parsed.problemId);
+  if (error) {
+    console.error(error);
+    return 1;
+  }
+
+  const snapshot = buildNumberTheoryStatusSnapshot(problem);
+  if (parsed.asJson) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return 0;
+  }
+
+  if (subcommand === 'frontier') {
+    printFrontier(snapshot);
+    return 0;
+  }
+  if (subcommand === 'routes') {
+    printRoutes(snapshot);
+    return 0;
+  }
+  if (subcommand === 'tickets') {
+    printTickets(snapshot);
+    return 0;
+  }
+
+  printStatus(snapshot);
+  return 0;
+}

package/src/commands/problem.js

@@ -94,6 +94,9 @@ function printProblem(problem) {
   console.log(`Repo status: ${problem.repoStatus}`);
   console.log(`Cluster: ${problem.cluster}`);
   console.log(`Harness depth: ${problem.harnessDepth}`);
+  if (String(problem.siteStatus).toLowerCase() === 'solved') {
+    console.log('Archive mode: method_exemplar');
+  }
   console.log(`Prize: ${problem.prize ?? '(none)'}`);
   console.log(`Formalization: ${problem.formalizationStatus}`);
   console.log(`Upstream formalized: ${problem.upstreamFormalizedState ?? '(unknown)'}`);

package/src/commands/pull.js

@@ -10,6 +10,7 @@ import { getProblemArtifactInventory, scaffoldProblem } from '../runtime/problem
 import { loadActiveUpstreamSnapshot, syncUpstream } from '../upstream/sync.js';
 import { fetchProblemSiteSnapshot } from '../upstream/site.js';
 import { buildProblemSearchQueries, fetchProblemPublicSearchReview } from '../upstream/public-search.js';
+import { fetchCrossrefLiterature, fetchOpenAlexLiterature } from '../upstream/literature.js';
 
 function normalizeClusterLabel(rawTag) {
   return String(rawTag ?? '')
@@ -44,13 +45,16 @@ function inferClusterFromUpstream(upstreamRecord) {
 function parsePullArgs(args) {
   const [kind, value, ...rest] = args;
   if (!['problem', 'artifacts', 'literature'].includes(kind)) {
-    return { error: 'Usage: erdos pull problem|artifacts|literature <id> [--dest <path>] [--include-site] [--refresh-upstream]' };
+    return { error: 'Usage: erdos pull problem|artifacts|literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]' };
   }
 
   let destination = null;
   let includeSite = false;
   let includePublicSearch = false;
+  let includeCrossref = false;
+  let includeOpenAlex = false;
   let refreshUpstream = false;
+  let asJson = false;
 
   for (let index = 0; index < rest.length; index += 1) {
     const token = rest[index];
@@ -70,10 +74,22 @@ function parsePullArgs(args) {
       includePublicSearch = true;
       continue;
     }
+    if (token === '--include-crossref') {
+      includeCrossref = true;
+      continue;
+    }
+    if (token === '--include-openalex') {
+      includeOpenAlex = true;
+      continue;
+    }
     if (token === '--refresh-upstream') {
       refreshUpstream = true;
       continue;
     }
+    if (token === '--json') {
+      asJson = true;
+      continue;
+    }
     return { error: `Unknown pull option: ${token}` };
   }
 
@@ -83,7 +99,10 @@ function parsePullArgs(args) {
     destination,
     includeSite,
     includePublicSearch,
+    includeCrossref,
+    includeOpenAlex,
     refreshUpstream,
+    asJson,
   };
 }
 
@@ -318,7 +337,66 @@ async function maybeWritePublicSearchBundle(problemId, title, destination, inclu
   }
 }
 
-async function writeLiteratureLane(problemId, destination, localProblem, upstreamRecord, includeSite, includePublicSearch) {
+async function maybeWriteLiteratureAdapter(problemId, title, destination, includeAdapter, label, fetcher) {
+  if (!includeAdapter) {
+    return {
+      attempted: false,
+      included: false,
+      error: null,
+      resultCount: 0,
+      filePrefix: label.toUpperCase(),
+    };
+  }
+
+  const filePrefix = label.toUpperCase();
+
+  try {
+    const payload = await fetcher(problemId, title);
+    writeJson(path.join(destination, `${filePrefix}_RESULTS.json`), payload);
+    writeText(
+      path.join(destination, `${filePrefix}_RESULTS.md`),
+      [
+        `# ${label} Results`,
+        '',
+        `Fetched at: ${payload.fetchedAt}`,
+        `Query: ${payload.query}`,
+        '',
+        ...(payload.results.length > 0
+          ? payload.results.map((result) => `- [${result.title || '(untitled)'}](${result.url || '#'})`)
+          : ['- *(no results captured)*']),
+        '',
+      ].join('\n'),
+    );
+    return {
+      attempted: true,
+      included: true,
+      error: null,
+      resultCount: payload.results.length,
+      filePrefix,
+    };
+  } catch (error) {
+    const message = String(error?.message ?? error);
+    writeText(path.join(destination, `${filePrefix}_ERROR.txt`), message);
+    return {
+      attempted: true,
+      included: false,
+      error: message,
+      resultCount: 0,
+      filePrefix,
+    };
+  }
+}
+
+async function writeLiteratureLane(
+  problemId,
+  destination,
+  localProblem,
+  upstreamRecord,
+  includeSite,
+  includePublicSearch,
+  includeCrossref,
+  includeOpenAlex,
+) {
   ensureDir(destination);
 
   const includedFiles = [];
@@ -355,6 +433,23 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
     destination,
     includePublicSearch,
   );
+  const literatureTitle = localProblem?.title ?? upstreamRecord?.title ?? `Erdos Problem #${problemId}`;
+  const crossref = await maybeWriteLiteratureAdapter(
+    problemId,
+    literatureTitle,
+    destination,
+    includeCrossref,
+    'Crossref',
+    fetchCrossrefLiterature,
+  );
+  const openalex = await maybeWriteLiteratureAdapter(
+    problemId,
+    literatureTitle,
+    destination,
+    includeOpenAlex,
+    'OpenAlex',
+    fetchOpenAlexLiterature,
+  );
   const problemRecord = buildProblemRecord(problemId, localProblem, upstreamRecord);
   writeJson(path.join(destination, 'PROBLEM.json'), problemRecord);
   writeJson(path.join(destination, 'LITERATURE_INDEX.json'), {
@@ -368,6 +463,10 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
     includedPublicSearch: publicSearch.included,
     publicSearchError: publicSearch.error,
     publicSearchQueries: publicSearch.queries,
+    includedCrossref: crossref.included,
+    crossrefError: crossref.error,
+    includedOpenAlex: openalex.included,
+    openAlexError: openalex.error,
   });
   writeText(
     path.join(destination, 'README.md'),
@@ -380,6 +479,8 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
       `- Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`,
       `- Live site snapshot included: ${siteStatus.included ? 'yes' : 'no'}`,
       `- Public search review included: ${publicSearch.included ? 'yes' : 'no'}`,
+      `- Crossref adapter included: ${crossref.included ? 'yes' : 'no'}`,
+      `- OpenAlex adapter included: ${openalex.included ? 'yes' : 'no'}`,
       '',
     ].join('\n'),
   );
@@ -389,6 +490,8 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
     includedFiles,
     siteStatus,
     publicSearch,
+    crossref,
+    openalex,
   };
 }
 
@@ -433,9 +536,9 @@ export async function runPullCommand(args, options = {}) {
   if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
     if (!silent) {
       console.log('Usage:');
-      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
-      console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
+      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
+      console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream] [--json]');
+      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
     }
     return 0;
   }
@@ -474,6 +577,17 @@ export async function runPullCommand(args, options = {}) {
       ? path.resolve(parsed.destination)
       : getWorkspaceProblemArtifactDir(parsed.problemId);
     const result = writeArtifactsLane(String(parsed.problemId), destination, localProblem, upstreamRecord, snapshot);
+    if (parsed.asJson) {
+      console.log(JSON.stringify({
+        kind: 'artifacts',
+        problemId: String(parsed.problemId),
+        destination,
+        localProblemIncluded: Boolean(localProblem),
+        upstreamRecordIncluded: Boolean(upstreamRecord),
+        artifactsCopied: result.copiedArtifacts?.length ?? result.artifactsCopied ?? 0,
+      }, null, 2));
+      return 0;
+    }
     if (!silent) {
       console.log(`Artifact bundle created: ${destination}`);
       console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
@@ -494,19 +608,47 @@ export async function runPullCommand(args, options = {}) {
       upstreamRecord,
       parsed.includeSite,
       parsed.includePublicSearch,
+      parsed.includeCrossref,
+      parsed.includeOpenAlex,
     );
+    if (parsed.asJson) {
+      console.log(JSON.stringify({
+        kind: 'literature',
+        problemId: String(parsed.problemId),
+        destination,
+        localProblemIncluded: Boolean(localProblem),
+        upstreamRecordIncluded: Boolean(upstreamRecord),
+        includedSiteSnapshot: result.siteStatus.included,
+        siteStatusError: result.siteStatus.error,
+        includedPublicSearch: result.publicSearch.included,
+        publicSearchError: result.publicSearch.error,
+        includedCrossref: result.crossref.included,
+        crossrefError: result.crossref.error,
+        includedOpenAlex: result.openalex.included,
+        openAlexError: result.openalex.error,
+      }, null, 2));
+      return 0;
+    }
     if (!silent) {
       console.log(`Literature bundle created: ${destination}`);
       console.log(`Local dossier context included: ${localProblem ? 'yes' : 'no'}`);
       console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
       console.log(`Live site snapshot included: ${result.siteStatus.included ? 'yes' : 'no'}`);
       console.log(`Public search review included: ${result.publicSearch.included ? 'yes' : 'no'}`);
+      console.log(`Crossref adapter included: ${result.crossref.included ? 'yes' : 'no'}`);
+      console.log(`OpenAlex adapter included: ${result.openalex.included ? 'yes' : 'no'}`);
       if (result.siteStatus.error) {
         console.log(`Live site snapshot note: ${result.siteStatus.error}`);
       }
       if (result.publicSearch.error) {
         console.log(`Public search note: ${result.publicSearch.error}`);
       }
+      if (result.crossref.error) {
+        console.log(`Crossref note: ${result.crossref.error}`);
+      }
+      if (result.openalex.error) {
+        console.log(`OpenAlex note: ${result.openalex.error}`);
+      }
     }
     return 0;
   }
@@ -526,6 +668,8 @@ export async function runPullCommand(args, options = {}) {
     upstreamRecord,
     parsed.includeSite,
     parsed.includePublicSearch,
+    parsed.includeCrossref,
+    parsed.includeOpenAlex,
   );
 
   writeJson(path.join(rootDestination, 'PULL_STATUS.json'), {
@@ -545,8 +689,31 @@ export async function runPullCommand(args, options = {}) {
     publicSearchAttempted: literatureResult.publicSearch.attempted,
     publicSearchIncluded: literatureResult.publicSearch.included,
     publicSearchError: literatureResult.publicSearch.error,
+    crossrefAttempted: literatureResult.crossref.attempted,
+    crossrefIncluded: literatureResult.crossref.included,
+    crossrefError: literatureResult.crossref.error,
+    openAlexAttempted: literatureResult.openalex.attempted,
+    openAlexIncluded: literatureResult.openalex.included,
+    openAlexError: literatureResult.openalex.error,
   });
 
+  if (parsed.asJson) {
+    console.log(JSON.stringify({
+      kind: 'problem',
+      problemId: String(parsed.problemId),
+      destination: rootDestination,
+      artifactsDir: artifactDestination,
+      literatureDir: literatureDestination,
+      localProblemIncluded: Boolean(localProblem),
+      upstreamRecordIncluded: Boolean(upstreamRecord),
+      includedSiteSnapshot: literatureResult.siteStatus.included,
+      includedPublicSearch: literatureResult.publicSearch.included,
+      includedCrossref: literatureResult.crossref.included,
+      includedOpenAlex: literatureResult.openalex.included,
+    }, null, 2));
+    return 0;
+  }
+
   if (!silent) {
     console.log(`Pull bundle created: ${rootDestination}`);
     console.log(`Artifact lane: ${artifactDestination}`);
@@ -555,12 +722,20 @@ export async function runPullCommand(args, options = {}) {
     console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
     console.log(`Live site snapshot included: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
     console.log(`Public search review included: ${literatureResult.publicSearch.included ? 'yes' : 'no'}`);
+    console.log(`Crossref adapter included: ${literatureResult.crossref.included ? 'yes' : 'no'}`);
+    console.log(`OpenAlex adapter included: ${literatureResult.openalex.included ? 'yes' : 'no'}`);
     if (literatureResult.siteStatus.error) {
       console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
     }
     if (literatureResult.publicSearch.error) {
       console.log(`Public search note: ${literatureResult.publicSearch.error}`);
     }
+    if (literatureResult.crossref.error) {
+      console.log(`Crossref note: ${literatureResult.crossref.error}`);
+    }
+    if (literatureResult.openalex.error) {
+      console.log(`OpenAlex note: ${literatureResult.openalex.error}`);
+    }
   }
   return 0;
 }