@longtable/cli 0.1.28 → 0.1.30

package/README.md

@@ -200,11 +200,18 @@ deduplicates, ranks, and labels results as evidence cards. Some sources work
 without keys, some require a contact email, and some need API keys for reliable
 use.
 
+Publisher access is configured separately through environment variables and
+DOI probes. `longtable search setup` checks Elsevier, Springer Nature, Wiley,
+and Taylor & Francis credentials or TDM tokens without storing secrets.
+
 Citation support should be checked explicitly. A reference can be useful as
 background while still failing to support the specific claim attached to it.
 
 ```bash
+longtable search setup
+longtable search probe --doi "10.1016/example" --publisher elsevier
 longtable search --query "trust calibration measurement" --intent measurement
+longtable search --query "trust calibration measurement" --publisher-access --json
 longtable search --query "trust calibration citation support" --intent citation --record
 ```
 

package/dist/cli.js

@@ -8,7 +8,7 @@ import { stdin as input, stdout as output, cwd, env, exit } from "node:process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
-import { assessSearchSourceCapabilities, buildResearchSearchIntent, runResearchSearch } from "@longtable/research-search";
+import { assessSearchSourceCapabilities, buildResearchSearchIntent, buildSearchCapabilitySnapshot, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, searchCapabilitySnapshotPath, summarizeConfiguredPublisherAccess } from "./search/index.js";
 import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupOutput, saveSetupAndRuntimeConfig, serializeSetupOutput, writeRuntimeConfig } from "@longtable/setup";
 import { buildCodexSkillSpecs, buildCodexThinWrappedPrompt, installCodexSkills, listInstalledCodexSkills, renderQuestionRecordPrompt, removeCodexSkills, resolveCodexSkillsDir, runCodexThinWrapper } from "@longtable/provider-codex";
 import { buildClaudeSkillSpecs, installClaudeSkills, listInstalledClaudeSkills, renderQuestionRecordInput, removeClaudeSkills, resolveClaudeSkillsDir } from "@longtable/provider-claude";
@@ -43,7 +43,7 @@ const ANSI = {
     green: "\u001B[32m"
 };
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
-const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.28";
+const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.30";
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {
@@ -89,7 +89,10 @@ function usage() {
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
         "  longtable mcp install [--provider codex|claude|all] [--write] [--checkpoint-ui off|interactive|strong] [--json] [--codex-config <path>] [--claude-settings <path>] [--package <spec>]",
-        "  longtable search --query <text> [--intent literature|theory|measurement|citation|metadata|venue] [--field <text>] [--source all|crossref,arxiv,openalex,semantic_scholar,pubmed,eric,doaj,unpaywall] [--must <term[,term]>] [--exclude <term[,term]>] [--limit <n>] [--allow-partial] [--record] [--cwd <path>] [--json]",
+        "  longtable search --query <text> [--intent literature|theory|measurement|citation|metadata|venue] [--field <text>] [--source all|crossref,arxiv,openalex,semantic_scholar,pubmed,eric,doaj,unpaywall] [--must <term[,term]>] [--exclude <term[,term]>] [--limit <n>] [--allow-partial] [--publisher-access] [--record] [--cwd <path>] [--json]",
+        "  longtable search setup [--doi <doi>] [--json]",
+        "  longtable search doctor [--doi <doi>] [--publisher auto|elsevier|springer_nature|wiley|taylor_francis|all] [--json]",
+        "  longtable search probe --doi <doi> [--publisher auto|elsevier|springer_nature|wiley|taylor_francis] [--json]",
         "  longtable sentinel --prompt <text> [--cwd <path>] [--json] [--record]",
         "  longtable team --prompt <text> [--role <role[,role]>] [--debate] [--rounds 3|5] [--cwd <path>] [--json]",
         "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
@@ -136,6 +139,10 @@ function parseArgs(argv) {
     else if (command === "codex" || command === "claude" || command === "mcp") {
         startIndex = 2;
     }
+    else if (command === "search" && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+        subcommand = maybeSubcommand;
+        startIndex = 2;
+    }
     else if (directCommand) {
         subcommand = undefined;
         startIndex = 1;
@@ -2013,6 +2020,7 @@ function renderEvidenceRunSummary(run, recordedPath) {
         ].filter(Boolean).join(", ");
         lines.push(`  - ${card.title}`);
         lines.push(`    score: ${card.relevanceScore}; support: ${card.citationSupportStatus}; depth: ${card.evidenceDepth}; sources: ${card.sourceRoutes.join(", ")}`);
+        lines.push(`    access: ${card.accessStatus}; verification: ${card.verificationNote}`);
         if (identifiers) {
             lines.push(`    ids: ${identifiers}`);
         }
@@ -2056,7 +2064,194 @@ async function recordEvidenceRun(run, workingDirectory) {
     await syncCurrentWorkspaceView(context);
     return evidencePath;
 }
-async function runSearch(args) {
+function renderPublisherAccessRecord(record) {
+    const envSummary = record.missingEnv.length > 0
+        ? `missing ${record.missingEnv.join(", ")}`
+        : `configured ${record.presentEnv.join(", ") || "none"}`;
+    const lines = [
+        `${record.publisher}:`,
+        `  credential: ${record.credentialStatus} (${envSummary})`,
+        `  entitlement: ${record.entitlementStatus}; tdm: ${record.tdmStatus}; depth: ${record.collectionDepth}`,
+        `  verification: ${record.verificationNote}`
+    ];
+    if (record.testedDoi) {
+        lines.push(`  tested doi: ${record.testedDoi}`);
+    }
+    if (record.endpoint) {
+        lines.push(`  endpoint: ${record.endpoint}`);
+    }
+    if (record.licenseNote) {
+        lines.push(`  license: ${record.licenseNote}`);
+    }
+    if (record.setupHint) {
+        lines.push(`  setup: ${record.setupHint}`);
+    }
+    return lines.join("\n");
+}
+function renderPublisherAccessRecords(title, records, capabilityPath) {
+    const lines = [title];
+    if (capabilityPath) {
+        lines.push(`- capability file: ${capabilityPath}`);
+    }
+    for (const record of records) {
+        lines.push(renderPublisherAccessRecord(record));
+    }
+    return lines.join("\n");
+}
+async function saveSearchCapabilityRecords(records) {
+    const snapshotPath = searchCapabilitySnapshotPath();
+    await mkdir(dirname(snapshotPath), { recursive: true });
+    await writeJsonFile(snapshotPath, buildSearchCapabilitySnapshot(records, env));
+    return snapshotPath;
+}
+async function probeAllPublishers(doi) {
+    const records = [];
+    for (const publisher of publisherConfigs()) {
+        records.push(await probePublisherAccess({
+            doi,
+            publisher: publisher.publisher,
+            env
+        }));
+    }
+    return records;
+}
+async function runSearchProbe(args) {
+    if (typeof args.doi !== "string" || !args.doi.trim()) {
+        throw new Error("`longtable search probe` requires --doi <doi>.");
+    }
+    const publisher = parsePublisherTarget(args.publisher);
+    const record = await probePublisherAccess({
+        doi: args.doi,
+        publisher,
+        env
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify({ record }, null, 2));
+    }
+    else {
+        console.log(renderPublisherAccessRecord(record));
+    }
+    return [record];
+}
+async function runSearchDoctor(args) {
+    let records;
+    if (typeof args.doi === "string" && args.doi.trim()) {
+        if (args.publisher === "all") {
+            records = await probeAllPublishers(args.doi);
+        }
+        else {
+            const publisher = parsePublisherTarget(args.publisher);
+            records = [await probePublisherAccess({
+                    doi: args.doi,
+                    publisher,
+                    env
+                })];
+        }
+    }
+    else {
+        records = summarizeConfiguredPublisherAccess(env);
+    }
+    const snapshotPath = searchCapabilitySnapshotPath();
+    const snapshotExists = existsSync(snapshotPath);
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            capabilityFile: snapshotPath,
+            capabilityFileExists: snapshotExists,
+            records
+        }, null, 2));
+    }
+    else {
+        console.log(renderPublisherAccessRecords("LongTable Search Publisher Access Doctor", records, snapshotPath));
+        if (!snapshotExists) {
+            console.log("- saved capabilities: none yet; run `longtable search setup` to record non-secret capability status.");
+        }
+    }
+    return records;
+}
+async function promptPublisherDoi(rl, label, defaultDoi) {
+    const prompt = defaultDoi
+        ? `${label} test DOI [${defaultDoi}, Enter to reuse, skip to skip]: `
+        : `${label} test DOI (Enter to skip): `;
+    const answer = (await rl.question(prompt)).trim();
+    if (!answer && defaultDoi) {
+        return defaultDoi;
+    }
+    if (!answer || /^skip$/i.test(answer)) {
+        return undefined;
+    }
+    return answer;
+}
+async function runInteractiveSearchSetup(defaultDoi) {
+    const rl = createInterface({ input, output });
+    const records = [];
+    try {
+        console.log("LongTable publisher access setup");
+        console.log("LongTable does not store API keys or TDM tokens. It reads environment variables and records only non-secret capability results.");
+        console.log("");
+        for (const publisher of publisherConfigs()) {
+            console.log(`${publisher.label}`);
+            console.log(`  required env: ${publisher.requiredEnv.join(", ")}`);
+            if (publisher.optionalEnv.length > 0) {
+                console.log(`  optional env: ${publisher.optionalEnv.join(", ")}`);
+            }
+            console.log(`  ${publisher.setupHint}`);
+            const doi = await promptPublisherDoi(rl, publisher.label, defaultDoi);
+            if (doi) {
+                records.push(await probePublisherAccess({
+                    doi,
+                    publisher: publisher.publisher,
+                    env
+                }));
+            }
+            else {
+                const summary = summarizeConfiguredPublisherAccess(env)
+                    .find((record) => record.publisher === publisher.publisher);
+                if (summary) {
+                    records.push(summary);
+                }
+            }
+            console.log(renderPublisherAccessRecord(records[records.length - 1]));
+            console.log("");
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return records;
+}
+async function runSearchSetup(args) {
+    const defaultDoi = typeof args.doi === "string" ? args.doi : undefined;
+    const records = input.isTTY && output.isTTY && args.json !== true
+        ? await runInteractiveSearchSetup(defaultDoi)
+        : defaultDoi
+            ? await probeAllPublishers(defaultDoi)
+            : summarizeConfiguredPublisherAccess(env);
+    const snapshotPath = await saveSearchCapabilityRecords(records);
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            capabilityFile: snapshotPath,
+            snapshot: buildSearchCapabilitySnapshot(records, env)
+        }, null, 2));
+        return;
+    }
+    console.log(renderPublisherAccessRecords("LongTable Search Publisher Access Setup", records, snapshotPath));
+}
+async function runSearch(subcommand, args) {
+    if (subcommand === "probe") {
+        await runSearchProbe(args);
+        return;
+    }
+    if (subcommand === "doctor" || subcommand === "status") {
+        await runSearchDoctor(args);
+        return;
+    }
+    if (subcommand === "setup") {
+        await runSearchSetup(args);
+        return;
+    }
+    if (subcommand) {
+        throw new Error(`Unknown search subcommand: ${subcommand}`);
+    }
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const projectContext = await loadProjectContextFromDirectory(workingDirectory);
     const searchInput = {
@@ -2082,7 +2277,8 @@ async function runSearch(args) {
     const run = await runResearchSearch({
         ...searchInput,
         env,
-        allowPartial
+        allowPartial,
+        publisherAccess: args["publisher-access"] === true
     });
     let recordedPath;
     if (args.record === true && run.status !== "blocked") {
@@ -2907,7 +3103,7 @@ async function main() {
         return;
     }
     if (command === "search") {
-        await runSearch(values);
+        await runSearch(subcommand, values);
         return;
     }
     if (command === "ask") {

package/dist/search/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./query.js";
+export * from "./sources.js";
+export * from "./rank.js";
+export * from "./run.js";
+export * from "./publisher-access.js";

package/dist/search/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./query.js";
+export * from "./sources.js";
+export * from "./rank.js";
+export * from "./run.js";
+export * from "./publisher-access.js";

package/dist/search/publisher-access.d.ts

@@ -0,0 +1,23 @@
+import { type CrossrefTdmDiscovery, type EvidenceCard, type Publisher, type PublisherAccessRecord, type PublisherProbeInput, type PublisherProbeTarget, type SearchCapabilitySnapshot, type SearchFetch } from "./types.js";
+interface PublisherConfig {
+    publisher: Publisher;
+    label: string;
+    requiredEnv: string[];
+    optionalEnv: string[];
+    setupHint: string;
+}
+export declare function normalizeDoi(value: string): string;
+export declare function parsePublisherTarget(value?: string | boolean): PublisherProbeTarget;
+export declare function discoverCrossrefTdm(doi: string, env?: Record<string, string | undefined>, httpFetch?: SearchFetch): Promise<CrossrefTdmDiscovery>;
+export declare function publisherConfigs(): PublisherConfig[];
+export declare function probePublisherAccess(input: PublisherProbeInput): Promise<PublisherAccessRecord>;
+export declare function summarizeConfiguredPublisherAccess(env?: Record<string, string | undefined>): PublisherAccessRecord[];
+export declare function buildSearchCapabilitySnapshot(records: PublisherAccessRecord[], env?: Record<string, string | undefined>): SearchCapabilitySnapshot;
+export declare function searchCapabilitySnapshotPath(home?: string): string;
+export declare function enrichCardsWithPublisherAccess(input: {
+    cards: EvidenceCard[];
+    env?: Record<string, string | undefined>;
+    fetch?: SearchFetch;
+    limit?: number;
+}): Promise<EvidenceCard[]>;
+export {};