@longtable/cli 0.1.58 → 0.1.60

package/dist/search/query.js

@@ -1,179 +0,0 @@
-import { SEARCH_SOURCES } from "./types.js";
-const STOP_WORDS = new Set([
-    "a",
-    "about",
-    "an",
-    "and",
-    "are",
-    "as",
-    "at",
-    "be",
-    "before",
-    "between",
-    "but",
-    "by",
-    "can",
-    "do",
-    "does",
-    "for",
-    "from",
-    "has",
-    "have",
-    "how",
-    "in",
-    "into",
-    "is",
-    "it",
-    "its",
-    "of",
-    "on",
-    "or",
-    "should",
-    "study",
-    "that",
-    "the",
-    "their",
-    "this",
-    "to",
-    "what",
-    "when",
-    "where",
-    "whether",
-    "which",
-    "with"
-]);
-function searchId() {
-    return `search_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-export function normalizeSearchText(value) {
-    return value
-        .toLowerCase()
-        .replace(/https?:\/\/\S+/g, " ")
-        .replace(/doi:\s*/g, "doi ")
-        .replace(/[^a-z0-9가-힣._:/-]+/gi, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-export function splitCsvTerms(value) {
-    if (!value) {
-        return [];
-    }
-    return value
-        .split(",")
-        .map((entry) => normalizeSearchText(entry))
-        .filter(Boolean);
-}
-export function extractSearchKeywords(text, limit = 12) {
-    const normalized = normalizeSearchText(text);
-    const counts = new Map();
-    for (const token of normalized.split(" ")) {
-        if (token.length < 3 || STOP_WORDS.has(token)) {
-            continue;
-        }
-        counts.set(token, (counts.get(token) ?? 0) + 1);
-    }
-    return [...counts.entries()]
-        .sort((a, b) => {
-        const countDelta = b[1] - a[1];
-        return countDelta !== 0 ? countDelta : a[0].localeCompare(b[0]);
-    })
-        .slice(0, limit)
-        .map(([token]) => token);
-}
-export function parseSearchSources(value) {
-    if (!value || value === "all") {
-        return [...SEARCH_SOURCES];
-    }
-    const requested = value
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    const sources = [];
-    for (const source of requested) {
-        if (!SEARCH_SOURCES.includes(source)) {
-            throw new Error(`Unknown search source: ${source}`);
-        }
-        sources.push(source);
-    }
-    return sources.length > 0 ? sources : [...SEARCH_SOURCES];
-}
-function inferIntentKind(text, explicit) {
-    if (explicit) {
-        if (explicit === "literature" ||
-            explicit === "theory" ||
-            explicit === "measurement" ||
-            explicit === "citation" ||
-            explicit === "metadata" ||
-            explicit === "venue") {
-            return explicit;
-        }
-        throw new Error(`Unknown search intent: ${explicit}`);
-    }
-    const normalized = normalizeSearchText(text);
-    if (/\b(citation|reference|doi|source|hallucination|verify|support)\b|인용|레퍼런스|출처|근거/.test(normalized)) {
-        return "citation";
-    }
-    if (/\b(scale|measure|measurement|instrument|validity|reliability)\b|측정|척도|타당도|도구/.test(normalized)) {
-        return "measurement";
-    }
-    if (/\b(theory|theoretical|framework|construct|conceptual)\b|이론|개념|프레임워크/.test(normalized)) {
-        return "theory";
-    }
-    if (/\b(journal|venue|conference|submission|scope|fit)\b|저널|학회|투고/.test(normalized)) {
-        return "venue";
-    }
-    if (/\b(metadata|pmid|arxiv|openalex|semantic scholar)\b/.test(normalized)) {
-        return "metadata";
-    }
-    return "literature";
-}
-function buildQueryVariants(baseQuery, keywords, field, mustTerms = []) {
-    const variants = new Set();
-    variants.add(baseQuery);
-    const compact = [...mustTerms, ...keywords].slice(0, 8).join(" ");
-    if (compact) {
-        variants.add(compact);
-    }
-    if (field && compact) {
-        variants.add(`${field} ${compact}`);
-    }
-    return [...variants].filter(Boolean).slice(0, 3);
-}
-export function buildResearchSearchIntent(input) {
-    const explicitQuery = input.query?.trim();
-    const baseText = explicitQuery || [
-        input.prompt,
-        input.projectGoal,
-        input.projectBlocker
-    ]
-        .filter((entry) => Boolean(entry && entry.trim()))
-        .join(" ");
-    if (!baseText.trim()) {
-        throw new Error("A search query is required. Pass --query or run inside a workspace with a current goal.");
-    }
-    const mustTerms = splitCsvTerms(input.must);
-    const excludeTerms = splitCsvTerms(input.exclude);
-    const field = input.field?.trim() || undefined;
-    const keywordText = [baseText, field, ...mustTerms].filter(Boolean).join(" ");
-    const keywords = extractSearchKeywords(keywordText);
-    const normalizedQuery = normalizeSearchText(baseText);
-    const query = keywords.length > 0 ? keywords.slice(0, 10).join(" ") : normalizedQuery;
-    const limit = Number.isInteger(input.limit) && input.limit && input.limit > 0
-        ? Math.min(input.limit, 50)
-        : 10;
-    return {
-        id: searchId(),
-        createdAt: new Date().toISOString(),
-        kind: inferIntentKind(baseText, input.intent),
-        query,
-        normalizedQuery,
-        queryVariants: buildQueryVariants(query, keywords, field, mustTerms),
-        keywords,
-        ...(field ? { field } : {}),
-        mustTerms,
-        excludeTerms,
-        requestedSources: parseSearchSources(input.sources),
-        limit,
-        source: input.source ?? "cli"
-    };
-}

package/dist/search/rank.d.ts

@@ -1,2 +0,0 @@
-import type { EvidenceCard, ResearchSearchIntent } from "./types.js";
-export declare function dedupeAndRankCards(cards: EvidenceCard[], intent: ResearchSearchIntent): EvidenceCard[];

package/dist/search/rank.js

@@ -1,173 +0,0 @@
-import { normalizeSearchText } from "./query.js";
-function keyForCard(card) {
-    if (card.doi)
-        return `doi:${card.doi.toLowerCase()}`;
-    if (card.pmid)
-        return `pmid:${card.pmid}`;
-    if (card.arxivId)
-        return `arxiv:${card.arxivId.toLowerCase()}`;
-    if (card.openAlexId)
-        return `openalex:${card.openAlexId}`;
-    if (card.semanticScholarId)
-        return `s2:${card.semanticScholarId}`;
-    const title = normalizeSearchText(card.title).replace(/\s+/g, "-");
-    return `title:${title}:${card.year ?? "unknown"}`;
-}
-function keywordMatches(card, keywords) {
-    const haystack = normalizeSearchText([
-        card.title,
-        card.abstract,
-        card.venue,
-        card.researchDesign,
-        card.mainFinding
-    ].filter(Boolean).join(" "));
-    return keywords.filter((keyword) => haystack.includes(normalizeSearchText(keyword)));
-}
-function sourceBoost(card) {
-    if (card.sourceRoutes.includes("openalex"))
-        return 6;
-    if (card.sourceRoutes.includes("semantic_scholar"))
-        return 5;
-    if (card.sourceRoutes.includes("pubmed"))
-        return 5;
-    if (card.sourceRoutes.includes("crossref"))
-        return 4;
-    if (card.sourceRoutes.includes("arxiv"))
-        return 3;
-    if (card.sourceRoutes.includes("doaj"))
-        return 3;
-    if (card.sourceRoutes.includes("eric"))
-        return 3;
-    return 1;
-}
-function supportStatus(card, matches, keywords) {
-    if (card.verificationDepth === "metadata" || !card.abstractAvailable) {
-        return "not_verified";
-    }
-    const ratio = keywords.length === 0 ? 0 : matches.length / keywords.length;
-    const fullTextChecked = card.verificationDepth === "licensed_snippet" || card.verificationDepth === "legal_full_text";
-    if (fullTextChecked && ratio >= 0.65)
-        return "direct_support";
-    if (ratio >= 0.35)
-        return "indirect_support";
-    if (ratio > 0)
-        return "background";
-    return "questionable_fit";
-}
-function scoreCard(card, intent, matches) {
-    const title = normalizeSearchText(card.title);
-    const abstract = normalizeSearchText(card.abstract ?? "");
-    let score = 0;
-    for (const keyword of intent.keywords) {
-        const normalized = normalizeSearchText(keyword);
-        if (title.includes(normalized))
-            score += 8;
-        if (abstract.includes(normalized))
-            score += 3;
-    }
-    for (const term of intent.mustTerms) {
-        const normalized = normalizeSearchText(term);
-        if (title.includes(normalized) || abstract.includes(normalized)) {
-            score += 10;
-        }
-        else {
-            score -= 20;
-        }
-    }
-    for (const term of intent.excludeTerms) {
-        const normalized = normalizeSearchText(term);
-        if (title.includes(normalized) || abstract.includes(normalized)) {
-            score -= 30;
-        }
-    }
-    if (card.year) {
-        const age = Math.max(0, new Date().getUTCFullYear() - card.year);
-        score += Math.max(0, 10 - Math.min(age, 10));
-    }
-    if (card.citationCount) {
-        score += Math.min(12, Math.log10(card.citationCount + 1) * 4);
-    }
-    if (card.legalFullTextAvailable)
-        score += 4;
-    score += sourceBoost(card);
-    score += matches.length * 2;
-    return Math.max(0, Math.round(score * 10) / 10);
-}
-function accessStrength(card) {
-    if (card.accessStatus === "licensed_full_text_checked")
-        return 6;
-    if (card.accessStatus === "licensed_full_text_available")
-        return 5;
-    if (card.accessStatus === "legal_full_text_available")
-        return 4;
-    if (card.accessStatus === "abstract_available")
-        return 3;
-    if (card.accessStatus === "metadata_only")
-        return 2;
-    if (card.accessStatus === "license_unknown")
-        return 1;
-    return 0;
-}
-function strongerAccess(existing, incoming) {
-    return accessStrength(incoming) > accessStrength(existing) ? incoming : existing;
-}
-function mergeCards(existing, incoming) {
-    const sourceRoutes = [...new Set([...existing.sourceRoutes, ...incoming.sourceRoutes])];
-    const stronger = strongerAccess(existing, incoming);
-    return {
-        ...existing,
-        authors: existing.authors.length > 0 ? existing.authors : incoming.authors,
-        year: existing.year ?? incoming.year,
-        venue: existing.venue ?? incoming.venue,
-        doi: existing.doi ?? incoming.doi,
-        pmid: existing.pmid ?? incoming.pmid,
-        arxivId: existing.arxivId ?? incoming.arxivId,
-        openAlexId: existing.openAlexId ?? incoming.openAlexId,
-        semanticScholarId: existing.semanticScholarId ?? incoming.semanticScholarId,
-        ericId: existing.ericId ?? incoming.ericId,
-        url: existing.url ?? incoming.url,
-        abstract: existing.abstract ?? incoming.abstract,
-        abstractAvailable: existing.abstractAvailable || incoming.abstractAvailable,
-        legalFullTextAvailable: existing.legalFullTextAvailable || incoming.legalFullTextAvailable,
-        fullTextUrl: existing.fullTextUrl ?? incoming.fullTextUrl,
-        publisher: existing.publisher ?? incoming.publisher,
-        entitlementSource: stronger.entitlementSource ?? existing.entitlementSource ?? incoming.entitlementSource,
-        collectionDepth: stronger.collectionDepth ?? existing.collectionDepth ?? incoming.collectionDepth,
-        licenseNote: stronger.licenseNote ?? existing.licenseNote ?? incoming.licenseNote,
-        publisherAccess: stronger.publisherAccess ?? existing.publisherAccess ?? incoming.publisherAccess,
-        accessStatus: stronger.accessStatus,
-        verificationDepth: stronger.verificationDepth,
-        verificationNote: stronger.verificationNote,
-        citationCount: Math.max(existing.citationCount ?? 0, incoming.citationCount ?? 0) || undefined,
-        researchDesign: existing.researchDesign ?? incoming.researchDesign,
-        constructsOrMeasures: [...new Set([...(existing.constructsOrMeasures ?? []), ...(incoming.constructsOrMeasures ?? [])])],
-        mainFinding: existing.mainFinding ?? incoming.mainFinding,
-        sourceRoutes,
-        limitations: [...new Set([...existing.limitations, ...incoming.limitations])],
-        matchedKeywords: [...new Set([...existing.matchedKeywords, ...incoming.matchedKeywords])],
-        relevanceScore: Math.max(existing.relevanceScore, incoming.relevanceScore)
-    };
-}
-export function dedupeAndRankCards(cards, intent) {
-    const byKey = new Map();
-    for (const card of cards) {
-        const matches = keywordMatches(card, intent.keywords);
-        const scored = {
-            ...card,
-            matchedKeywords: matches,
-            citationSupportStatus: supportStatus(card, matches, intent.keywords),
-            relevanceScore: scoreCard(card, intent, matches)
-        };
-        const key = keyForCard(scored);
-        const existing = byKey.get(key);
-        byKey.set(key, existing ? mergeCards(existing, scored) : scored);
-    }
-    return [...byKey.values()]
-        .sort((a, b) => {
-        const scoreDelta = b.relevanceScore - a.relevanceScore;
-        if (scoreDelta !== 0)
-            return scoreDelta;
-        return (b.year ?? 0) - (a.year ?? 0);
-    })
-        .slice(0, intent.limit);
-}

package/dist/search/run.d.ts

@@ -1,2 +0,0 @@
-import type { EvidenceRun, RunResearchSearchInput } from "./types.js";
-export declare function runResearchSearch(input: RunResearchSearchInput): Promise<EvidenceRun>;

package/dist/search/run.js

@@ -1,114 +0,0 @@
-import { buildResearchSearchIntent } from "./query.js";
-import { dedupeAndRankCards } from "./rank.js";
-import { enrichCardsWithPublisherAccess } from "./publisher-access.js";
-import { assessSearchSourceCapabilities, runSourceSearch } from "./sources.js";
-function runId() {
-    return `evidence_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function now() {
-    return new Date().toISOString();
-}
-function defaultFetch() {
-    if (typeof fetch !== "function") {
-        throw new Error("LongTable search requires a fetch-capable Node runtime.");
-    }
-    return fetch;
-}
-export async function runResearchSearch(input) {
-    const createdAt = now();
-    const id = runId();
-    const intent = buildResearchSearchIntent(input);
-    const env = input.env ?? process.env;
-    const capabilities = assessSearchSourceCapabilities(intent.requestedSources, env);
-    const skippedSources = capabilities.filter((capability) => !capability.enabled);
-    if (skippedSources.length > 0 && input.allowPartial !== true) {
-        const updatedAt = now();
-        return {
-            id,
-            createdAt,
-            updatedAt,
-            status: "blocked",
-            intent,
-            sourceReports: skippedSources.map((capability) => ({
-                source: capability.source,
-                status: "skipped",
-                count: 0,
-                elapsedMs: 0,
-                reason: capability.reason
-            })),
-            cards: [],
-            skippedSources,
-            warnings: skippedSources.map((capability) => capability.reason ?? `${capability.source} unavailable.`),
-            blockedReason: "One or more requested scholarly sources are unavailable. Confirm partial search or configure credentials."
-        };
-    }
-    const httpFetch = input.fetch ?? defaultFetch();
-    const sourceReports = [];
-    const cards = [];
-    for (const capability of capabilities) {
-        if (!capability.enabled) {
-            sourceReports.push({
-                source: capability.source,
-                status: "skipped",
-                count: 0,
-                elapsedMs: 0,
-                reason: capability.reason
-            });
-            continue;
-        }
-        const started = Date.now();
-        try {
-            const result = await runSourceSearch({
-                intent,
-                source: capability.source,
-                limit: intent.limit
-            }, {
-                fetch: httpFetch,
-                env
-            });
-            cards.push(...result.cards);
-            sourceReports.push({
-                source: capability.source,
-                status: "completed",
-                count: result.cards.length,
-                elapsedMs: Date.now() - started,
-                endpoint: result.endpoint
-            });
-        }
-        catch (error) {
-            sourceReports.push({
-                source: capability.source,
-                status: "failed",
-                count: 0,
-                elapsedMs: Date.now() - started,
-                reason: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    const rankedCards = dedupeAndRankCards(cards, intent);
-    const finalCards = input.publisherAccess === true
-        ? await enrichCardsWithPublisherAccess({
-            cards: rankedCards,
-            env,
-            fetch: httpFetch
-        })
-        : rankedCards;
-    const hasFailure = sourceReports.some((report) => report.status === "failed" || report.status === "skipped");
-    const status = hasFailure ? "partial" : "completed";
-    return {
-        id,
-        createdAt,
-        updatedAt: now(),
-        status,
-        intent,
-        sourceReports,
-        cards: finalCards,
-        skippedSources,
-        warnings: [
-            ...skippedSources.map((capability) => capability.reason ?? `${capability.source} unavailable.`),
-            ...sourceReports
-                .filter((report) => report.status === "failed")
-                .map((report) => `${report.source} failed: ${report.reason ?? "unknown error"}`)
-        ]
-    };
-}

package/dist/search/sources.d.ts

@@ -1,5 +0,0 @@
-import { type SearchSource, type SearchSourceCapability, type SourceSearchContext, type SourceSearchRequest, type SourceSearchResult } from "./types.js";
-export declare function assessSearchSourceCapabilities(sources: SearchSource[], env?: Record<string, string | undefined>): SearchSourceCapability[];
-export declare function enabledSearchSources(sources: SearchSource[], env?: Record<string, string | undefined>): SearchSource[];
-export declare function runSourceSearch(request: SourceSearchRequest, context: SourceSearchContext): Promise<SourceSearchResult>;
-export declare function allSearchSources(): SearchSource[];