@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/artifacts/corpus-tools/cli.js

@@ -0,0 +1,393 @@
+/**
+ * `aiwg corpus` subcommand router — radar/freshness tools (#1498).
+ *
+ * Mirrors src/artifacts/cli.ts (the `aiwg index` router): a thin arg parser that
+ * resolves the corpus root (env > research.corpusRoot > cwd, via build.ts's
+ * resolveCorpusRoot) and dispatches to the corpus-tools functions. The
+ * research-complete radar-* skills wrap these subcommands.
+ *
+ * Subcommands:
+ *   radar-init   --ref REF-XXX | --all-missing [--cadence C] [--cluster T] [--write]
+ *   radar-status [--stale-only] [--format table|csv|list] [--out PATH]
+ *   radar-report [--cluster T] [--out PATH]
+ *
+ * @source historical: corpus/radar_init.py, radar_staleness.py, radar_report.py
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveCorpusRoot } from '../corpus-views/build.js';
+import { scaffoldRadar, radarInitMissing } from './radar-init.js';
+import { radarStatusRows, renderRadarStatus } from './radar-status.js';
+import { renderRadarReport } from './radar-report.js';
+import { profileStatusRows, renderProfileStatus } from './profile-status.js';
+import { generateTier1Profiles } from './profile-generate.js';
+import { generateFmProfiles } from './profile-generate-fm.js';
+import { curatorRows, curatorOrphans, renderCuratorStatus, scaffoldCurator } from './curator.js';
+import { logDiscovery } from './discovery-log.js';
+import { computeMetrics, renderMetrics } from './profile-metrics.js';
+import { computeTrajectory, renderTrajectory } from './profile-temporal.js';
+import { detectCommunities, detectSkosCommunities, renderCommunities, renderSkosCommunities } from './profile-communities.js';
+import { funderRows, cofundingClusters, renderFunderNetwork } from './funder-network.js';
+import { lintSidecars, renderLint, findOrphans, renderOrphans } from './sidecar-lint.js';
+import { repairAuthors, normalizeAffiliations, renderRepair } from './sidecar-repair.js';
+import { extractCrossrefs, renderCrossrefs, backfillCitations, renderBackfill } from './citation-densify.js';
+import { scanCorpus, renderScan, writeQuarantineReports, failsThreshold } from './integrity-scan.js';
+import { loadSourceTypeRegistry, renderSourceTypes } from './source-types.js';
+import { auditInductions, renderAudit, backfillFrontmatter, renderBackfill as renderBackfillFm } from './induction-audit.js';
+import { buildProfileEdges, renderProfileEdges } from './profile-edges.js';
+import { extractPages, renderExtract, resolveAdapter, rasterizePdf } from './vision-extract.js';
+import { runSnapshot } from './snapshot.js';
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    return i !== -1 && i + 1 < args.length ? args[i + 1] : undefined;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+const HELP = `aiwg corpus — research-corpus tools
+
+Usage:
+  aiwg corpus radar-init --ref REF-XXX [--cadence C] [--cluster T] [--write]
+  aiwg corpus radar-init --all-missing [--write]
+  aiwg corpus radar-status [--stale-only] [--format table|csv|list] [--out PATH]
+  aiwg corpus radar-report [--cluster TAG] [--out PATH]
+  aiwg corpus profile-status [--stale-only] [--format table|csv|list] [--out PATH]
+  aiwg corpus profile-generate [--limit N] [--scan N] [--write]
+  aiwg corpus profile-generate --fm [--write]
+  aiwg corpus curator-status [--out PATH]
+  aiwg corpus curator-init --handle @h [--platform x] [--name "N"] [--cadence weekly] [--write]
+  aiwg corpus discovery-log --ref REF-XXX --surface SURFACE [--via "..."] [--curator PROF-S-x] [--date D] [--batch B] [--by A] [--write]
+  aiwg corpus profile-metrics [--papers] [--out PATH]
+  aiwg corpus profile-temporal --entity PROF-P-x [--out PATH]
+  aiwg corpus profile-communities [--skos-export PATH] [--out PATH]
+  aiwg corpus funder-network [--scan-acks] [--out PATH]
+  aiwg corpus sidecar-lint [--orphans] [--out PATH]
+  aiwg corpus sidecar-repair [--authors-only | --affiliations-only] [--write] [--out PATH]
+  aiwg corpus extract-crossrefs [--refs REF-a,REF-b] [--write] [--out PATH]
+  aiwg corpus citation-backfill [--write] [--out PATH]
+  aiwg corpus integrity-scan [--ref REF-XXX] [--quarantine] [--fail-on review|quarantine] [--out PATH]
+  aiwg corpus source-types [--json] [--out PATH]
+  aiwg corpus induction-audit [--start N --end N | --ref REF-XXX] [--out PATH]
+  aiwg corpus snapshot [--compute-only] [--delta-only] [--template PATH] [--format full|summary|json] [--out PATH] [--date YYYY-MM-DD] [--write] [--notes TEXT]
+  aiwg corpus frontmatter-backfill [--write] [--out PATH]
+  aiwg corpus profile-edges [--out PATH]
+  aiwg corpus profile-similar --entity PROF-P-x [--top K] | --predict-collabs [--threshold T] [--out PATH]
+  aiwg corpus vision-extract --slug SLUG [--images DIR] [--out DIR] [--start N] [--end N] [--provider codex|command] [--command TMPL] [--model M] [--retries N] [--title T] [--force] [--rasterize PDF] [--dpi N]
+
+radar-init scaffolds radar sidecars (dry-run unless --write; skips existing).
+radar-status reports overdue radars (most-overdue-first).
+radar-report aggregates corpus/cluster freshness.
+profile-status reports entity profiles past their refresh cadence.
+profile-generate scaffolds PROF-P profiles for unprofiled hub authors (dry-run unless --write).
+profile-generate --fm scaffolds FM-author PROF-P + group PROF-G profiles from documentation/profiles/fm-config.yaml.
+curator-status reports PROF-S curators by yield (return-to score) + discovery orphans.
+curator-init scaffolds a PROF-S source/curator profile from a handle.
+discovery-log records the discovery block on a citation sidecar.
+profile-metrics computes h-index / CD-index / PageRank / centrality per profile (--papers for paper-level).
+profile-temporal computes publication trajectory + hot-streak for one profile.
+profile-communities detects co-author communities + modularity + bridge authors; --skos-export groups Fortemi v2 records by extracted SKOS concepts.
+funder-network reports per-funder yield (A-grade, mean CD, novelty bias) + co-funding clusters.
+sidecar-lint reports citation-sidecar structural issues (missing sections/frontmatter, duplicate table headers); --orphans lists zero-edge sidecars.
+sidecar-repair backfills (see REF doc) authors from the analysis citation block + normalizes affiliation-primary to PROF-O slugs (dry-run unless --write).
+extract-crossrefs injects analysis-doc Cross-References REFs (that have a sidecar) as missing outgoing edges (dry-run unless --write).
+citation-backfill computes the inverse citation map + injects missing incoming edges; reports dangling cited-but-no-sidecar targets (dry-run unless --write).
+integrity-scan flags LLM residue / placeholders / submission risks per REF (pass/review/quarantine); --quarantine writes per-REF reports; --fail-on exits non-zero at threshold.
+source-types lists the canonical source-type registry (paper/preprint/blog/repo/…) that normalizes the type/source_type/Source-Type vocabularies; override per-corpus at documentation/source-types.yaml.
+induction-audit checks induction depth-bands + structural integrity + per-source-type required sections (a blog isn't flagged for missing Benchmark Results).
+snapshot computes one-shot corpus snapshot metrics and renders full markdown, terminal summary, or JSON; --write emits .aiwg/reports/corpus-snapshot-YYYY-MM-DD.md.
+frontmatter-backfill adds minimal ref_id/title/year/pdf_hash frontmatter to legacy analysis docs lacking it (dry-run unless --write; additive, skips docs that already have frontmatter).
+profile-edges builds the profile→REF edge graph (first-class adjacency; reconciled against the citation graph so only edges to existing REFs are kept).
+profile-similar embeds person profiles (text-embedding; opt-in @xenova/transformers) → nearest researchers (--entity) or collaboration link-prediction (--predict-collabs).
+vision-extract transcribes scanned page PNGs → per-page + combined Markdown via a provider-neutral vision adapter (codex | command template), resumable with retry/validation; --rasterize PDF first renders pages via pdftoppm.
+`;
+function radarInit(root, args) {
+    const write = hasFlag(args, '--write');
+    const cadence = flagValue(args, '--cadence');
+    const cluster = flagValue(args, '--cluster');
+    if (hasFlag(args, '--all-missing')) {
+        const results = radarInitMissing(root, { cadence, cluster, write });
+        console.log(`Refs missing radars: ${results.length}`);
+        for (const r of results)
+            console.log('  ' + r.message);
+        return;
+    }
+    const ref = flagValue(args, '--ref');
+    if (!ref)
+        throw new Error('radar-init requires --ref <REF-XXX> or --all-missing');
+    console.log(scaffoldRadar(root, ref, { cadence, cluster, write }).message);
+}
+function radarStatus(root, args) {
+    const staleOnly = hasFlag(args, '--stale-only');
+    const format = (flagValue(args, '--format') ?? 'table');
+    if (!['table', 'csv', 'list'].includes(format)) {
+        throw new Error(`radar-status: invalid --format '${format}' (table|csv|list)`);
+    }
+    const content = renderRadarStatus(radarStatusRows(root, { staleOnly }), format);
+    emit(content, flagValue(args, '--out'), root);
+}
+function radarReport(root, args) {
+    const content = renderRadarReport(root, { cluster: flagValue(args, '--cluster') });
+    emit(content, flagValue(args, '--out'), root);
+}
+function profileStatus(root, args) {
+    const staleOnly = hasFlag(args, '--stale-only');
+    const format = (flagValue(args, '--format') ?? 'table');
+    if (!['table', 'csv', 'list'].includes(format)) {
+        throw new Error(`profile-status: invalid --format '${format}' (table|csv|list)`);
+    }
+    const content = renderProfileStatus(profileStatusRows(root, { staleOnly }), format);
+    emit(content, flagValue(args, '--out'), root);
+}
+function profileGenerate(root, args) {
+    const write = hasFlag(args, '--write');
+    if (hasFlag(args, '--fm')) {
+        const results = generateFmProfiles(root, { write });
+        console.log(`FM profiles (from fm-config.yaml): ${results.length}`);
+        for (const r of results)
+            console.log('  ' + r.message);
+        return;
+    }
+    const limit = flagValue(args, '--limit');
+    const scan = flagValue(args, '--scan');
+    const results = generateTier1Profiles(root, {
+        write,
+        limit: limit ? parseInt(limit, 10) : undefined,
+        scan: scan ? parseInt(scan, 10) : undefined,
+    });
+    console.log(`Tier-1 candidates: ${results.length}`);
+    for (const r of results)
+        console.log('  ' + r.message);
+}
+function curatorInit(root, args) {
+    const handle = flagValue(args, '--handle');
+    if (!handle)
+        throw new Error('curator-init requires --handle <@account>');
+    const res = scaffoldCurator(root, handle, {
+        platform: flagValue(args, '--platform'),
+        name: flagValue(args, '--name'),
+        cadence: flagValue(args, '--cadence'),
+        write: hasFlag(args, '--write'),
+    });
+    console.log(res.message);
+}
+function discoveryLog(root, args) {
+    const ref = flagValue(args, '--ref');
+    const surface = flagValue(args, '--surface');
+    if (!ref || !surface)
+        throw new Error('discovery-log requires --ref <REF-XXX> and --surface <surface>');
+    const res = logDiscovery(root, ref, {
+        surface,
+        via: flagValue(args, '--via'),
+        curatorId: flagValue(args, '--curator'),
+        date: flagValue(args, '--date'),
+        harvestBatch: flagValue(args, '--batch'),
+        harvestedBy: flagValue(args, '--by'),
+        write: hasFlag(args, '--write'),
+    });
+    console.log(res.message);
+    if (res.status === 'dry-run') {
+        console.log('--- discovery block ---');
+        console.log(res.block);
+    }
+}
+function profileTemporal(root, args) {
+    const entity = flagValue(args, '--entity');
+    if (!entity)
+        throw new Error('profile-temporal requires --entity <PROF-P-x>');
+    emit(renderTrajectory(computeTrajectory(root, entity)), flagValue(args, '--out'), root);
+}
+function sidecarLint(root, args) {
+    if (hasFlag(args, '--orphans')) {
+        emit(renderOrphans(findOrphans(root)), flagValue(args, '--out'), root);
+        return;
+    }
+    emit(renderLint(lintSidecars(root)), flagValue(args, '--out'), root);
+}
+function sidecarRepair(root, args) {
+    const write = hasFlag(args, '--write');
+    const authorsOnly = hasFlag(args, '--authors-only');
+    const affilOnly = hasFlag(args, '--affiliations-only');
+    const authors = affilOnly ? [] : repairAuthors(root, { write });
+    const affil = authorsOnly
+        ? { normalized: 0, alreadyCanonical: 0, ambiguous: [], errors: [], changes: [] }
+        : normalizeAffiliations(root, { write });
+    emit(renderRepair(authors, affil, write), flagValue(args, '--out'), root);
+}
+function snapshot(root, args) {
+    const format = (flagValue(args, '--format') ?? 'full');
+    if (!['full', 'summary', 'json'].includes(format ?? '')) {
+        throw new Error(`snapshot: invalid --format '${format}' (full|summary|json)`);
+    }
+    const result = runSnapshot(root, {
+        computeOnly: hasFlag(args, '--compute-only'),
+        deltaOnly: hasFlag(args, '--delta-only'),
+        write: hasFlag(args, '--write'),
+        template: flagValue(args, '--template'),
+        format,
+        out: flagValue(args, '--out'),
+        date: flagValue(args, '--date'),
+        notes: flagValue(args, '--notes'),
+    });
+    if (result.outPath) {
+        console.log(`Wrote ${path.relative(root, result.outPath)}`);
+        return;
+    }
+    process.stdout.write(result.content);
+}
+/** Write to --out (resolved against the corpus root) or print to stdout. */
+function emit(content, out, root) {
+    if (!out) {
+        process.stdout.write(content);
+        return;
+    }
+    const outPath = path.isAbsolute(out) ? out : path.join(root, out);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, content, 'utf-8');
+    console.log(`Wrote ${path.relative(root, outPath)}`);
+}
+/** Route `aiwg corpus <subcommand> [...args]`. Throws on error (handler maps to exit code). */
+export async function corpusMain(args, cwd = process.cwd()) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        process.stdout.write(HELP);
+        return;
+    }
+    const root = await resolveCorpusRoot(cwd);
+    switch (sub) {
+        case 'radar-init':
+            return radarInit(root, rest);
+        case 'radar-status':
+            return radarStatus(root, rest);
+        case 'radar-report':
+            return radarReport(root, rest);
+        case 'profile-status':
+            return profileStatus(root, rest);
+        case 'profile-generate':
+            return profileGenerate(root, rest);
+        case 'curator-status':
+            return emit(renderCuratorStatus(curatorRows(root), curatorOrphans(root)), flagValue(rest, '--out'), root);
+        case 'curator-init':
+            return curatorInit(root, rest);
+        case 'discovery-log':
+            return discoveryLog(root, rest);
+        case 'profile-metrics':
+            return emit(renderMetrics(computeMetrics(root), hasFlag(rest, '--papers') ? 'papers' : 'people'), flagValue(rest, '--out'), root);
+        case 'profile-temporal':
+            return profileTemporal(root, rest);
+        case 'profile-communities':
+            if (flagValue(rest, '--skos-export')) {
+                const exportPath = path.resolve(root, flagValue(rest, '--skos-export'));
+                const exported = JSON.parse(fs.readFileSync(exportPath, 'utf-8'));
+                return emit(renderSkosCommunities(detectSkosCommunities(exported)), flagValue(rest, '--out'), root);
+            }
+            return emit(renderCommunities(detectCommunities(root)), flagValue(rest, '--out'), root);
+        case 'funder-network':
+            return emit(renderFunderNetwork(funderRows(root, { scanAcks: hasFlag(rest, '--scan-acks') }), cofundingClusters(root)), flagValue(rest, '--out'), root);
+        case 'sidecar-lint':
+            return sidecarLint(root, rest);
+        case 'sidecar-repair':
+            return sidecarRepair(root, rest);
+        case 'extract-crossrefs': {
+            const refs = flagValue(rest, '--refs')?.split(',').map((s) => s.trim()).filter(Boolean);
+            const write = hasFlag(rest, '--write');
+            return emit(renderCrossrefs(extractCrossrefs(root, { refs, write }), write), flagValue(rest, '--out'), root);
+        }
+        case 'citation-backfill': {
+            const write = hasFlag(rest, '--write');
+            return emit(renderBackfill(backfillCitations(root, { write }), write), flagValue(rest, '--out'), root);
+        }
+        case 'integrity-scan': {
+            const result = scanCorpus(root, { ref: flagValue(rest, '--ref') });
+            emit(renderScan(result), flagValue(rest, '--out'), root);
+            if (hasFlag(rest, '--quarantine')) {
+                const written = writeQuarantineReports(root, result);
+                if (written.length) {
+                    console.log('\nQuarantine reports written:');
+                    for (const w of written)
+                        console.log(`  ${w}`);
+                }
+            }
+            const failOn = flagValue(rest, '--fail-on');
+            if (failOn === 'review' || failOn === 'quarantine') {
+                if (failsThreshold(result, failOn))
+                    throw new Error(`integrity-scan: REFs reached '${failOn}' threshold`);
+            }
+            return;
+        }
+        case 'source-types': {
+            const reg = loadSourceTypeRegistry(root);
+            if (hasFlag(rest, '--json')) {
+                emit(JSON.stringify(reg, null, 2) + '\n', flagValue(rest, '--out'), root);
+            }
+            else {
+                emit(renderSourceTypes(reg), flagValue(rest, '--out'), root);
+            }
+            return;
+        }
+        case 'induction-audit': {
+            const startStr = flagValue(rest, '--start');
+            const endStr = flagValue(rest, '--end');
+            const ref = flagValue(rest, '--ref');
+            const results = auditInductions(root, {
+                start: startStr ? parseInt(startStr, 10) : undefined,
+                end: endStr ? parseInt(endStr, 10) : undefined,
+                refs: ref ? [ref] : undefined,
+            });
+            return emit(renderAudit(results), flagValue(rest, '--out'), root);
+        }
+        case 'snapshot':
+            return snapshot(root, rest);
+        case 'frontmatter-backfill': {
+            const write = hasFlag(rest, '--write');
+            return emit(renderBackfillFm(backfillFrontmatter(root, { write }), write), flagValue(rest, '--out'), root);
+        }
+        case 'profile-edges':
+            return emit(renderProfileEdges(buildProfileEdges(root)), flagValue(rest, '--out'), root);
+        case 'vision-extract': {
+            const slug = flagValue(rest, '--slug');
+            if (!slug)
+                throw new Error('vision-extract requires --slug <slug>');
+            const imageDir = flagValue(rest, '--images') ?? path.join(root, '.aiwg', 'research', 'sources', 'images', slug, 'pages');
+            const outDir = flagValue(rest, '--out') ?? path.join(root, '.aiwg', 'research', 'sources', 'text', `${slug}-vision`);
+            const pdf = flagValue(rest, '--rasterize');
+            if (pdf) {
+                const dpi = flagValue(rest, '--dpi') ? parseInt(flagValue(rest, '--dpi'), 10) : 200;
+                const n = rasterizePdf(path.isAbsolute(pdf) ? pdf : path.join(root, pdf), imageDir, dpi);
+                console.log(`Rasterized ${n} pages → ${imageDir}`);
+            }
+            const adapter = resolveAdapter({ provider: flagValue(rest, '--provider'), command: flagValue(rest, '--command') });
+            const result = await extractPages({
+                imageDir,
+                outDir,
+                adapter,
+                title: flagValue(rest, '--title'),
+                start: flagValue(rest, '--start') ? parseInt(flagValue(rest, '--start'), 10) : undefined,
+                end: flagValue(rest, '--end') ? parseInt(flagValue(rest, '--end'), 10) : undefined,
+                retries: flagValue(rest, '--retries') ? parseInt(flagValue(rest, '--retries'), 10) : undefined,
+                model: flagValue(rest, '--model'),
+                force: hasFlag(rest, '--force'),
+            });
+            console.log(renderExtract(result));
+            console.log(`  per-page + combined → ${outDir}`);
+            return;
+        }
+        case 'profile-similar': {
+            const { buildProfileEmbeddings, profileSimilar, collaborationPredictions, renderSimilar, renderCollabPredictions } = await import('./profile-embed.js');
+            const emb = await buildProfileEmbeddings(root);
+            if (hasFlag(rest, '--predict-collabs')) {
+                const threshold = flagValue(rest, '--threshold') ? parseFloat(flagValue(rest, '--threshold')) : 0.8;
+                return emit(renderCollabPredictions(collaborationPredictions(emb, threshold), threshold), flagValue(rest, '--out'), root);
+            }
+            const entity = flagValue(rest, '--entity');
+            if (!entity)
+                throw new Error('profile-similar requires --entity <PROF-P-x> or --predict-collabs');
+            const top = flagValue(rest, '--top') ? parseInt(flagValue(rest, '--top'), 10) : 10;
+            return emit(renderSimilar(entity, profileSimilar(emb, entity, top)), flagValue(rest, '--out'), root);
+        }
+        default:
+            process.stderr.write(`Unknown corpus subcommand: ${sub}\n\n${HELP}`);
+            throw new Error(`unknown corpus subcommand: ${sub}`);
+    }
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/artifacts/corpus-tools/corpus-graph.js

@@ -0,0 +1,225 @@
+/**
+ * Corpus graph construction + analytics algorithms (#1501).
+ *
+ * NetworkX-equivalent ports (no graph library): co-author + citation graphs from
+ * the #1497 parser, plus h-index, CD-index (disruption), PageRank, betweenness,
+ * eigenvector, and clustering. Used by profile-metrics / profile-communities.
+ *
+ * @source historical: profiles/build_graphs.py, profiles/compute_metrics.py
+ * References: Hirsch 2005 (h-index); Wu-Wang-Evans 2019 (CD-index);
+ *   Brandes 2001 (betweenness); Newman 2003 (centrality).
+ */
+/** Build the citation graph from corpus outgoing edges (in-corpus targets only). */
+export function buildCitationGraph(records) {
+    const inCorpus = new Set(records.map((r) => r.refId));
+    const out = new Map();
+    const inn = new Map();
+    for (const r of records) {
+        out.set(r.refId, out.get(r.refId) ?? new Set());
+        inn.set(r.refId, inn.get(r.refId) ?? new Set());
+    }
+    for (const r of records) {
+        for (const t of r.outgoing) {
+            if (!inCorpus.has(t) || t === r.refId)
+                continue;
+            out.get(r.refId).add(t);
+            inn.get(t).add(r.refId);
+        }
+    }
+    return { nodes: records.map((r) => r.refId), out, in: inn };
+}
+/** Undirected co-author graph: person → (person → shared-paper weight). */
+export function buildCoauthorGraph(records) {
+    const g = new Map();
+    const link = (a, b) => {
+        const m = g.get(a) ?? g.set(a, new Map()).get(a);
+        m.set(b, (m.get(b) ?? 0) + 1);
+    };
+    for (const r of records) {
+        const authors = [...new Set(r.authors)];
+        for (let i = 0; i < authors.length; i++) {
+            if (!g.has(authors[i]))
+                g.set(authors[i], new Map());
+            for (let j = i + 1; j < authors.length; j++) {
+                link(authors[i], authors[j]);
+                link(authors[j], authors[i]);
+            }
+        }
+    }
+    return g;
+}
+/** h-index: max k such that ≥k papers have ≥k in-corpus citations (Hirsch 2005). */
+export function hIndex(citationCounts) {
+    const sorted = [...citationCounts].sort((a, b) => b - a);
+    let h = 0;
+    for (let i = 0; i < sorted.length; i++) {
+        if (sorted[i] >= i + 1)
+            h = i + 1;
+        else
+            break;
+    }
+    return h;
+}
+/**
+ * CD-index (disruption): (F − B) / (F + B + N). +1 fully disruptive, −1 consolidating.
+ * Null when < 3 citers (low confidence). Wu-Wang-Evans 2019.
+ */
+export function cdIndex(ref, g) {
+    if (!g.out.has(ref))
+        return null;
+    const citers = g.in.get(ref) ?? new Set();
+    const references = g.out.get(ref) ?? new Set();
+    if (citers.size < 3)
+        return null;
+    let F = 0;
+    let B = 0;
+    for (const c of citers) {
+        const cOut = g.out.get(c) ?? new Set();
+        let citesARef = false;
+        for (const x of references)
+            if (cOut.has(x)) {
+                citesARef = true;
+                break;
+            }
+        if (citesARef)
+            B++;
+        else
+            F++;
+    }
+    const citersOfRefs = new Set();
+    for (const rf of references)
+        for (const p of g.in.get(rf) ?? new Set())
+            citersOfRefs.add(p);
+    citersOfRefs.delete(ref);
+    for (const c of citers)
+        citersOfRefs.delete(c);
+    const N = citersOfRefs.size;
+    const denom = F + B + N;
+    return denom > 0 ? (F - B) / denom : 0;
+}
+/** PageRank over the directed citation graph (α=0.85), with dangling redistribution. */
+export function pageRank(g, alpha = 0.85, maxIter = 200, tol = 1e-6) {
+    const nodes = g.nodes;
+    const n = nodes.length;
+    if (n === 0)
+        return new Map();
+    let pr = new Map(nodes.map((x) => [x, 1 / n]));
+    const outDeg = new Map(nodes.map((x) => [x, (g.out.get(x) ?? new Set()).size]));
+    for (let iter = 0; iter < maxIter; iter++) {
+        const next = new Map(nodes.map((x) => [x, 0]));
+        let dangling = 0;
+        for (const x of nodes)
+            if (outDeg.get(x) === 0)
+                dangling += pr.get(x);
+        const base = (1 - alpha) / n + (alpha * dangling) / n;
+        for (const x of nodes)
+            next.set(x, base);
+        for (const x of nodes) {
+            const deg = outDeg.get(x);
+            if (deg === 0)
+                continue;
+            const share = (alpha * pr.get(x)) / deg;
+            for (const t of g.out.get(x))
+                next.set(t, next.get(t) + share);
+        }
+        let diff = 0;
+        for (const x of nodes)
+            diff += Math.abs(next.get(x) - pr.get(x));
+        pr = next;
+        if (diff < tol)
+            break;
+    }
+    return pr;
+}
+/** Brandes betweenness centrality on an undirected unweighted graph, normalized. */
+export function betweenness(g) {
+    const nodes = [...g.keys()];
+    const cb = new Map(nodes.map((x) => [x, 0]));
+    for (const s of nodes) {
+        const stack = [];
+        const pred = new Map(nodes.map((x) => [x, []]));
+        const sigma = new Map(nodes.map((x) => [x, 0]));
+        const dist = new Map(nodes.map((x) => [x, -1]));
+        sigma.set(s, 1);
+        dist.set(s, 0);
+        const queue = [s];
+        while (queue.length) {
+            const v = queue.shift();
+            stack.push(v);
+            for (const w of (g.get(v) ?? new Map()).keys()) {
+                if (dist.get(w) < 0) {
+                    queue.push(w);
+                    dist.set(w, dist.get(v) + 1);
+                }
+                if (dist.get(w) === dist.get(v) + 1) {
+                    sigma.set(w, sigma.get(w) + sigma.get(v));
+                    pred.get(w).push(v);
+                }
+            }
+        }
+        const delta = new Map(nodes.map((x) => [x, 0]));
+        while (stack.length) {
+            const w = stack.pop();
+            for (const v of pred.get(w)) {
+                delta.set(v, delta.get(v) + (sigma.get(v) / sigma.get(w)) * (1 + delta.get(w)));
+            }
+            if (w !== s)
+                cb.set(w, cb.get(w) + delta.get(w));
+        }
+    }
+    // Undirected normalization: divide by 2, then scale to [0,1].
+    const nn = nodes.length;
+    const scale = nn > 2 ? 1 / ((nn - 1) * (nn - 2)) : 1;
+    for (const x of nodes)
+        cb.set(x, (cb.get(x) / 2) * 2 * scale);
+    return cb;
+}
+/** Eigenvector centrality via power iteration on the undirected (weighted) graph. */
+export function eigenvector(g, maxIter = 500, tol = 1e-6) {
+    const nodes = [...g.keys()];
+    const n = nodes.length;
+    if (n === 0)
+        return new Map();
+    let x = new Map(nodes.map((k) => [k, 1 / n]));
+    for (let iter = 0; iter < maxIter; iter++) {
+        const xLast = x;
+        x = new Map(nodes.map((k) => [k, 0]));
+        for (const v of nodes) {
+            let acc = xLast.get(v);
+            for (const [w, weight] of g.get(v) ?? new Map())
+                acc += xLast.get(w) * weight;
+            x.set(v, acc);
+        }
+        const norm = Math.sqrt([...x.values()].reduce((a, b) => a + b * b, 0)) || 1;
+        for (const k of nodes)
+            x.set(k, x.get(k) / norm);
+        let diff = 0;
+        for (const k of nodes)
+            diff += Math.abs(x.get(k) - xLast.get(k));
+        if (diff < n * tol)
+            break;
+    }
+    return x;
+}
+/** Local clustering coefficient per node on the undirected graph. */
+export function clustering(g) {
+    const cc = new Map();
+    for (const [v, nbrsMap] of g) {
+        const nbrs = [...nbrsMap.keys()];
+        const k = nbrs.length;
+        if (k < 2) {
+            cc.set(v, 0);
+            continue;
+        }
+        let links = 0;
+        for (let i = 0; i < nbrs.length; i++) {
+            for (let j = i + 1; j < nbrs.length; j++) {
+                if ((g.get(nbrs[i]) ?? new Map()).has(nbrs[j]))
+                    links++;
+            }
+        }
+        cc.set(v, (2 * links) / (k * (k - 1)));
+    }
+    return cc;
+}
+//# sourceMappingURL=corpus-graph.js.map