sheeply 0.0.0-stage → 0.1.0

package/dist/analysis/entry-maturity.js

@@ -0,0 +1,72 @@
+import { identified } from "./investments.js";
+import { countShare, rate, ratio, summarise, tally } from "./ratio.js";
+import { STAGE_BUCKETS, normaliseLabel, stageBucket } from "./stages.js";
+const POSITIONS = ["0", "1", "2", "3+", "uncertain"];
+const position = (prior, uncertain) => uncertain > 0 ? "uncertain" : prior >= 3 ? "3+" : String(prior);
+/**
+ * Stage of the round in which the investor first appears on each company, from Dealroom's own
+ * `round_label`. Company age and prior capital are reported beside it to explain the stage, not
+ * scored: they measure the same company maturity.
+ */
+export function entryMaturity(history) {
+    const companies = identified(history);
+    const initials = companies.map((company) => company.initial);
+    const counts = Object.fromEntries(STAGE_BUCKETS.map((bucket) => [bucket, 0]));
+    const noLabel = [];
+    const unmapped = [];
+    for (const round of initials) {
+        const bucket = stageBucket(round.roundLabel);
+        if (bucket)
+            counts[bucket]++;
+        else if (round.roundLabel === null)
+            noLabel.push(round.standardizedRound ?? "(none)");
+        else
+            unmapped.push(normaliseLabel(round.roundLabel));
+    }
+    const total = initials.length;
+    const known = total - noLabel.length - unmapped.length;
+    const distribution = Object.fromEntries(STAGE_BUCKETS.map((bucket) => [bucket, { ...countShare(counts[bucket], total), share_of_known_stage: ratio(counts[bucket], known) }]));
+    const entries = companies.map((company) => company.entry);
+    const positions = entries.map((entry) => position(entry.priorVcRounds, entry.uncertainVcRounds));
+    const positionCounts = tally(positions);
+    const atFirst = companies.filter((c) => c.entry.uncertainVcRounds === 0 && c.entry.companyFirstVcRoundId === c.initial.id).length;
+    const certain = positions.filter((p) => p !== "uncertain").length;
+    const ages = entries.map((entry) => entry.companyAgeAtEntryYears).filter((age) => age !== null);
+    const completeCapital = entries.filter((entry) => entry.uncertainVcRounds === 0 && entry.priorVcRoundsWithoutAmount === 0);
+    const currencies = [...new Set(initials.map((round) => round.currency).filter(Boolean))];
+    return {
+        role: "metric",
+        question: "How early does this investor enter companies?",
+        stage_source: "round_label",
+        first_investments: total,
+        known_stage: known,
+        distribution: { ...distribution, unknown: { ...countShare(total - known, total), share_of_known_stage: null } },
+        unknown_breakdown: {
+            no_round_label_by_standardized_round: tally(noLabel),
+            unmapped_round_labels: tally(unmapped),
+        },
+        first_investments_by_standardized_round: tally(initials.map((round) => round.standardizedRound ?? "(none)")),
+        explanatory_attributes: {
+            note: "Descriptive context for entry stage. Not scored: company age and prior capital measure the same maturity as stage.",
+            entry_position: {
+                basis: "company VC rounds dated definitely before the investor's first observed round",
+                prior_vc_rounds: Object.fromEntries(POSITIONS.map((p) => [p, countShare(positionCounts[p] ?? 0, total)])),
+                entered_at_company_first_known_vc_round: rate(atFirst, certain),
+            },
+            company_age_at_entry_years: {
+                basis: "entry year minus company launch year",
+                known: ages.length,
+                unknown: total - ages.length,
+                entry_before_recorded_launch: ages.filter((age) => age < 0).length,
+                summary: summarise(ages.filter((age) => age >= 0)),
+            },
+            prior_vc_capital: {
+                basis: "sum of disclosed amounts of company VC rounds definitely before the entry",
+                currency: currencies.length === 1 ? currencies[0] : null,
+                complete: completeCapital.length,
+                incomplete: total - completeCapital.length,
+                summary_of_complete: summarise(completeCapital.map((entry) => entry.priorVcCapital)),
+            },
+        },
+    };
+}

package/dist/analysis/interpretation.js

@@ -0,0 +1,105 @@
+/**
+ * Fixed thresholds behind every statement. They describe this investor's own observed data; none
+ * is a market benchmark, so statements say "most" or "a minority", never "high" or "low". Only the
+ * two metrics are interpreted; sector exposure and syndicate relationships stay descriptive.
+ */
+export const THRESHOLDS = {
+    minimumSample: 10,
+    majorityShare: 0.5,
+    lowCoverage: 0.7,
+};
+const pct = (share) => (share === null ? "n/a" : `${Math.round(share * 100)}%`);
+export function interpret(entry, leadership, quality) {
+    const out = [];
+    const t = THRESHOLDS;
+    const d = entry.distribution;
+    const early = d.pre_seed.count + d.seed.count;
+    const later = d.series_a.count + d.series_b_plus.count;
+    if (entry.known_stage < t.minimumSample) {
+        out.push({
+            rule: "entry_maturity.insufficient_sample",
+            statement: `Too few first investments with a known stage (${entry.known_stage}) to describe entry maturity.`,
+            evidence: { known_stage: entry.known_stage, minimum_sample: t.minimumSample },
+        });
+    }
+    else {
+        const earlyShare = early / entry.known_stage;
+        const majority = earlyShare >= t.majorityShare;
+        out.push({
+            rule: majority ? "entry_maturity.majority_pre_seed_or_seed" : "entry_maturity.majority_series_a_or_later",
+            statement: `${majority ? "Most" : "A minority of"} first investments with a known stage were at pre-seed or seed ` +
+                `(${early} of ${entry.known_stage}, ${pct(earlyShare)}). A further ${d.unknown.count} of ${entry.first_investments} ` +
+                `first investments (${pct(d.unknown.share)}) have no Dealroom stage.`,
+            evidence: {
+                pre_seed_or_seed: early,
+                series_a_or_later: later,
+                known_stage: entry.known_stage,
+                unknown_stage: d.unknown.count,
+                threshold: t.majorityShare,
+            },
+        });
+        const atFirst = entry.explanatory_attributes.entry_position.entered_at_company_first_known_vc_round;
+        out.push({
+            rule: "entry_maturity.entry_position",
+            statement: `The first observed investment was the company's earliest known VC round in ${atFirst.numerator} of ${atFirst.denominator} companies (${pct(atFirst.value)}).`,
+            evidence: { numerator: atFirst.numerator, denominator: atFirst.denominator },
+        });
+    }
+    const initial = leadership.initial_investments;
+    const leadRate = initial.lead_rate;
+    if (initial.usable_lead_status < t.minimumSample) {
+        out.push({
+            rule: "investment_leadership.insufficient_sample",
+            statement: `Too few first investments with a usable lead status (${initial.usable_lead_status}) to describe lead behaviour.`,
+            evidence: { usable_lead_status: initial.usable_lead_status, minimum_sample: t.minimumSample },
+        });
+    }
+    else {
+        const majority = (leadRate.value ?? 0) >= t.majorityShare;
+        out.push({
+            rule: majority ? "investment_leadership.led_majority" : "investment_leadership.led_minority",
+            statement: `Recorded as lead or co-lead on ${majority ? "most" : "a minority"} of first investments with a usable lead status (${leadRate.numerator} of ${leadRate.denominator}, ${pct(leadRate.value)}).`,
+            evidence: { numerator: leadRate.numerator, denominator: leadRate.denominator, threshold: t.majorityShare },
+        });
+        if (!majority) {
+            out.push({
+                rule: "investment_leadership.caveat",
+                statement: "A minority lead rate alone does not establish follower behaviour: it is also consistent with deliberate co-investing, and the lead flag shows observed participation, not who originated the round.",
+                evidence: {},
+            });
+        }
+    }
+    const asReported = initial.sensitivity.lead_rate_if_every_false_is_non_lead;
+    if (initial.false_with_no_lead_on_round > 0 && leadRate.value !== null) {
+        out.push({
+            rule: "investment_leadership.sensitivity",
+            statement: `${initial.false_with_no_lead_on_round} first investments are on rounds where nobody is flagged as lead. Reading every false flag as a confirmed non-lead would give ${pct(asReported.value)} instead of ${pct(leadRate.value)}.`,
+            evidence: {
+                false_with_no_lead_on_round: initial.false_with_no_lead_on_round,
+                lead_rate: leadRate.value,
+                lead_rate_if_every_false_is_non_lead: asReported.value,
+            },
+        });
+    }
+    for (const [key, label] of [
+        ["entry_stage", "entry stage"],
+        ["lead_status", "lead status"],
+    ]) {
+        const coverage = quality.coverage[key];
+        if (coverage.value !== null && coverage.value < t.lowCoverage) {
+            out.push({
+                rule: `data_quality.${key}_coverage`,
+                statement: `Only ${coverage.numerator} of ${coverage.denominator} first investments (${pct(coverage.value)}) have a usable ${label}, so that figure describes a subset that may not be representative.`,
+                evidence: { numerator: coverage.numerator, denominator: coverage.denominator, threshold: t.lowCoverage },
+            });
+        }
+    }
+    if (quality.portfolio.complete === false) {
+        out.push({
+            rule: "data_quality.portfolio_incomplete",
+            statement: `Dealroom reports ${quality.portfolio.reported_by_dealroom} portfolio companies but returned ${quality.portfolio.rows_returned}.`,
+            evidence: { reported: quality.portfolio.reported_by_dealroom, returned: quality.portfolio.rows_returned },
+        });
+    }
+    return out;
+}

package/dist/analysis/investments.js

@@ -0,0 +1,107 @@
+import { compareStrings } from "../util.js";
+import { dateSpan, definitelyBefore, overlaps } from "./partial-date.js";
+import { stageRank } from "./stages.js";
+export const participantOf = (round, entityId) => round.participants.find((participant) => participant.id === entityId);
+/**
+ * Chronological order using only facts known at the time of each round: the announced date, then
+ * the earlier stage, then the Dealroom id. Undated rounds sort last because they cannot be placed.
+ */
+export function compareRounds(a, b) {
+    const spanA = dateSpan(a.announcedDate);
+    const spanB = dateSpan(b.announcedDate);
+    if (spanA === null || spanB === null) {
+        if (spanA !== spanB)
+            return spanA === null ? 1 : -1;
+    }
+    else {
+        const byDate = compareStrings(spanA.start, spanB.start) || compareStrings(spanA.end, spanB.end);
+        if (byDate !== 0)
+            return byDate;
+    }
+    return stageRank(a.roundLabel) - stageRank(b.roundLabel) || a.id - b.id;
+}
+export function buildInvestmentHistory(dataset) {
+    const investorId = dataset.investor.id;
+    const roundsByCompany = new Map();
+    for (const round of dataset.rounds) {
+        const list = roundsByCompany.get(round.companyId) ?? [];
+        list.push(round);
+        roundsByCompany.set(round.companyId, list);
+    }
+    const companies = dataset.portfolio.map((entry) => {
+        const companyRounds = [...(roundsByCompany.get(entry.companyId) ?? [])].sort(compareRounds);
+        const participations = companyRounds.filter((round) => participantOf(round, investorId));
+        const [initial = null, ...followOns] = participations;
+        let status;
+        if (entry.companySubtype !== null && entry.companySubtype !== "company")
+            status = "not_a_company";
+        else if (initial)
+            status = "initial_identified";
+        else if (entry.roundsCount === 0)
+            status = "no_round_attribution";
+        else if (companyRounds.some((round) => !round.investorsDisclosed))
+            status = "participation_undisclosed";
+        else
+            status = "rounds_not_matched";
+        const identified = status === "initial_identified" && initial !== null;
+        return {
+            companyId: entry.companyId,
+            companyName: entry.companyName,
+            status,
+            roundsCountReported: entry.roundsCount,
+            companyRoundsObserved: companyRounds.length,
+            participations,
+            initial: identified ? initial : null,
+            followOns: identified ? followOns : [],
+            flags: identified ? flagsFor(initial, followOns, companyRounds) : [],
+            entry: identified ? entryContext(initial, companyRounds, dataset.companies[entry.companyId]) : null,
+        };
+    });
+    const portfolioIds = new Set(dataset.portfolio.map((entry) => entry.companyId));
+    return {
+        investorId,
+        companies,
+        roundsOutsidePortfolio: dataset.rounds.filter((round) => !portfolioIds.has(round.companyId)),
+    };
+}
+/** True unless `round` is definitely after the entry, i.e. it could have come first. */
+const mayPrecede = (round, entrySpan) => {
+    const span = dateSpan(round.announcedDate);
+    return entrySpan === null || span === null || !definitelyBefore(entrySpan, span);
+};
+function flagsFor(initial, followOns, companyRounds) {
+    const flags = [];
+    const initialSpan = dateSpan(initial.announcedDate);
+    if (initialSpan === null)
+        flags.push("initial_undated");
+    if (followOns.some((round) => round.announcedDate === null) && initialSpan !== null)
+        flags.push("undated_participation");
+    const next = followOns[0];
+    const nextSpan = next ? dateSpan(next.announcedDate) : null;
+    if (initialSpan && nextSpan && overlaps(initialSpan, nextSpan))
+        flags.push("initial_ordering_ambiguous");
+    if (companyRounds.some((round) => !round.investorsDisclosed && round.id !== initial.id && mayPrecede(round, initialSpan))) {
+        flags.push("earlier_round_investors_undisclosed");
+    }
+    return flags;
+}
+function entryContext(initial, companyRounds, company) {
+    const entrySpan = dateSpan(initial.announcedDate);
+    const vcRounds = companyRounds.filter((round) => round.isVcRound === true);
+    const others = vcRounds.filter((round) => round.id !== initial.id);
+    const prior = others.filter((round) => {
+        const span = dateSpan(round.announcedDate);
+        return entrySpan !== null && span !== null && definitelyBefore(span, entrySpan);
+    });
+    const entryYear = initial.announcedDate === null ? null : Number(initial.announcedDate.slice(0, 4));
+    const launchYear = company?.launchDate ? Number(company.launchDate.slice(0, 4)) : null;
+    return {
+        companyFirstVcRoundId: vcRounds[0]?.id ?? null,
+        priorVcRounds: prior.length,
+        uncertainVcRounds: others.filter((round) => !prior.includes(round) && mayPrecede(round, entrySpan)).length,
+        priorVcCapital: prior.reduce((sum, round) => sum + (round.amount ?? 0), 0),
+        priorVcRoundsWithoutAmount: prior.filter((round) => round.amount === null).length,
+        companyAgeAtEntryYears: entryYear === null || launchYear === null ? null : entryYear - launchYear,
+    };
+}
+export const identified = (history) => history.companies.filter((company) => company.initial !== null);

package/dist/analysis/leadership.js

@@ -0,0 +1,42 @@
+import { identified, participantOf } from "./investments.js";
+import { rate } from "./ratio.js";
+/** Reads only the round's own participant flags; announcement dates never decide who led. */
+export function leadStatus(round, investorId) {
+    const self = participantOf(round, investorId);
+    if (!self || self.isLead === null)
+        return "unknown";
+    const otherLead = round.participants.some((p) => p.id !== investorId && p.isLead === true);
+    if (self.isLead)
+        return otherLead ? "co_lead" : "sole_lead";
+    return otherLead ? "not_led" : "no_lead_recorded";
+}
+export function leadStats(rounds, investorId) {
+    const counts = { sole_lead: 0, co_lead: 0, not_led: 0, no_lead_recorded: 0, unknown: 0 };
+    for (const round of rounds)
+        counts[leadStatus(round, investorId)]++;
+    const led = counts.sole_lead + counts.co_lead;
+    const usable = led + counts.not_led;
+    return {
+        rounds: rounds.length,
+        recorded_lead: led,
+        sole_lead: counts.sole_lead,
+        co_lead: counts.co_lead,
+        recorded_non_lead: counts.not_led,
+        false_with_no_lead_on_round: counts.no_lead_recorded,
+        null_lead_flag: counts.unknown,
+        usable_lead_status: usable,
+        lead_rate: rate(led, usable),
+        lead_status_completeness: rate(usable, rounds.length),
+        sensitivity: { lead_rate_if_every_false_is_non_lead: rate(led, usable + counts.no_lead_recorded) },
+    };
+}
+export function investmentLeadership(history) {
+    const companies = identified(history);
+    return {
+        role: "metric",
+        question: "How frequently does this investor lead its initial investments?",
+        measures: "Dealroom's lead flag on the investor's first observed participation in each company. This is observable participation, not who originated or committed first.",
+        initial_investments: leadStats(companies.map((company) => company.initial), history.investorId),
+        all_participations: leadStats(companies.flatMap((company) => company.participations), history.investorId),
+    };
+}

package/dist/analysis/partial-date.js

@@ -0,0 +1,17 @@
+export function dateSpan(value) {
+    if (value === null)
+        return null;
+    const [year, month, day] = value.split("-");
+    if (!year)
+        return null;
+    if (day && month)
+        return { start: value, end: value, precision: "day" };
+    if (month) {
+        const lastDay = new Date(Date.UTC(Number(year), Number(month), 0)).getUTCDate();
+        return { start: `${year}-${month}-01`, end: `${year}-${month}-${String(lastDay).padStart(2, "0")}`, precision: "month" };
+    }
+    return { start: `${year}-01-01`, end: `${year}-12-31`, precision: "year" };
+}
+/** True only when every day `a` could mean falls before every day `b` could mean. */
+export const definitelyBefore = (a, b) => a.end < b.start;
+export const overlaps = (a, b) => !definitelyBefore(a, b) && !definitelyBefore(b, a);

package/dist/analysis/ratio.js

@@ -0,0 +1,28 @@
+/** A share rounded to four decimals, or null when the denominator is empty rather than a misleading zero. */
+export function ratio(numerator, denominator) {
+    if (denominator === 0)
+        return null;
+    return Math.round((numerator / denominator) * 10_000) / 10_000;
+}
+export const countShare = (count, denominator) => ({ count, share: ratio(count, denominator) });
+export const rate = (numerator, denominator) => ({ numerator, denominator, value: ratio(numerator, denominator) });
+export function tally(values) {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    return Object.fromEntries([...counts].sort(([a, x], [b, y]) => y - x || (a < b ? -1 : a > b ? 1 : 0)));
+}
+/** Quartiles by linear interpolation between order statistics, rounded to two decimals. */
+export function summarise(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const at = (q) => {
+        if (sorted.length === 0)
+            return null;
+        const position = (sorted.length - 1) * q;
+        const low = Math.floor(position);
+        const high = Math.ceil(position);
+        const value = sorted[low] + (sorted[high] - sorted[low]) * (position - low);
+        return Math.round(value * 100) / 100;
+    };
+    return { n: sorted.length, min: at(0), p25: at(0.25), median: at(0.5), p75: at(0.75), max: at(1) };
+}

package/dist/analysis/sector-exposure.js

@@ -0,0 +1,64 @@
+import { compareStrings } from "../util.js";
+import { identified } from "./investments.js";
+import { ratio } from "./ratio.js";
+export const SECTOR_FAMILY = "industry";
+/**
+ * Multi-label industry exposure of the companies behind the first investments. Dealroom exposes no
+ * mutually exclusive sector field, so a company with two industries counts in both and shares can
+ * sum past one. This is the company's current classification, not the one at investment time.
+ */
+export function sectorExposure(history, companies) {
+    const analysed = identified(history).map((c) => companies[c.companyId]);
+    const counts = new Map();
+    let notReturned = 0;
+    let without = 0;
+    let multiple = 0;
+    let assignments = 0;
+    let maxLabels = 0;
+    for (const company of analysed) {
+        if (!company || !company.taxonomyKnown) {
+            notReturned++;
+            continue;
+        }
+        const industries = company.taxonomy.filter((term) => term.type === SECTOR_FAMILY);
+        if (industries.length === 0)
+            without++;
+        if (industries.length > 1)
+            multiple++;
+        assignments += industries.length;
+        maxLabels = Math.max(maxLabels, industries.length);
+        for (const term of industries) {
+            const entry = counts.get(term.id) ?? { name: term.name, companies: 0, weight: 0 };
+            entry.companies++;
+            entry.weight += 1 / industries.length;
+            counts.set(term.id, entry);
+        }
+    }
+    const labelled = analysed.length - notReturned - without;
+    const distribution = [...counts]
+        .sort(([idA, a], [idB, b]) => b.companies - a.companies || compareStrings(a.name, b.name) || idA - idB)
+        .map(([id, entry]) => ({ id, name: entry.name, companies: entry.companies, share: ratio(entry.companies, labelled) }));
+    const concentration = [...counts.values()].reduce((sum, entry) => sum + (entry.weight / labelled) ** 2, 0);
+    return {
+        role: "descriptive",
+        question: "Which sectors does this investor enter?",
+        classification: {
+            exclusive_sector_classification_available: false,
+            family: SECTOR_FAMILY,
+            note: "Dealroom's API exposes no mutually exclusive sector field. Industry is its highest-level classification and a company can hold two, so shares can sum past 100%.",
+            max_labels_per_company_observed: maxLabels,
+        },
+        first_investments: analysed.length,
+        taxonomy_not_returned: notReturned,
+        without_industry: without,
+        labelled,
+        with_multiple_industries: multiple,
+        label_assignments: assignments,
+        distribution,
+        breadth: {
+            distinct_industries: counts.size,
+            top_industry_share: distribution[0]?.share ?? null,
+            effective_number_of_industries: labelled === 0 ? null : Math.round((1 / concentration) * 100) / 100,
+        },
+    };
+}

package/dist/analysis/stages.js

@@ -0,0 +1,30 @@
+export const STAGE_BUCKETS = ["pre_seed", "seed", "series_a", "series_b_plus"];
+/** Dealroom returns `round_label` as e.g. "MICRO-SEED" or "SERIES A EXTENSION"; reference data spells it "Micro-Seed". */
+export function normaliseLabel(label) {
+    return label
+        .toUpperCase()
+        .replace(/[^A-Z0-9+]+/g, " ")
+        .trim();
+}
+/**
+ * Maps Dealroom's own stage label to an entry-maturity bucket. Labels outside the documented
+ * Pre-Seed to Series F ladder return null so they are reported as unmapped, not guessed.
+ */
+export function stageBucket(roundLabel) {
+    if (roundLabel === null)
+        return null;
+    const label = normaliseLabel(roundLabel);
+    if (label === "PRE SEED")
+        return "pre_seed";
+    if (["MICRO SEED", "SEED", "SEED+", "SEED EXTENSION"].includes(label))
+        return "seed";
+    if (label === "SERIES A" || label === "SERIES A EXTENSION")
+        return "series_a";
+    if (/^SERIES [B-Z]( EXTENSION)?$/.test(label))
+        return "series_b_plus";
+    return null;
+}
+export function stageRank(roundLabel) {
+    const bucket = stageBucket(roundLabel);
+    return bucket === null ? STAGE_BUCKETS.length : STAGE_BUCKETS.indexOf(bucket);
+}

package/dist/analysis/syndicates.js

@@ -0,0 +1,70 @@
+import { compareStrings } from "../util.js";
+import { identified } from "./investments.js";
+import { leadStatus } from "./leadership.js";
+import { ratio } from "./ratio.js";
+export const TOP_PARTNERS = 10;
+function rank(tallies, denominator) {
+    return [...tallies.values()]
+        .sort((a, b) => b.rounds - a.rounds || compareStrings(a.participant.name, b.participant.name) || compareStrings(a.participant.id, b.participant.id))
+        .map(({ participant, rounds }) => ({
+        id: participant.id,
+        name: participant.name,
+        type: participant.type,
+        subtype: participant.subtype,
+        rounds,
+        share: ratio(rounds, denominator),
+    }));
+}
+function add(tallies, participant, weight) {
+    const entry = tallies.get(participant.id) ?? { participant, rounds: 0, weight: 0 };
+    entry.rounds++;
+    entry.weight += weight;
+    tallies.set(participant.id, entry);
+}
+/**
+ * Who led the initial rounds this investor joined while another investor led, and who it co-invests with.
+ * A round with several leads credits each of them once in the counts; the Herfindahl index splits
+ * that round's weight equally so shares sum to one.
+ */
+export function syndicates(history) {
+    const investorId = history.investorId;
+    const companies = identified(history);
+    const ledByOthers = companies.map((c) => c.initial).filter((round) => leadStatus(round, investorId) === "not_led");
+    const leads = new Map();
+    for (const round of ledByOthers) {
+        const roundLeads = round.participants.filter((p) => p.id !== investorId && p.isLead === true);
+        for (const lead of roundLeads)
+            add(leads, lead, 1 / roundLeads.length);
+    }
+    const n = ledByOthers.length;
+    const rankedLeads = rank(leads, n);
+    const herfindahl = n === 0 ? null : Math.round([...leads.values()].reduce((sum, t) => sum + (t.weight / n) ** 2, 0) * 10_000) / 10_000;
+    const disclosed = companies.flatMap((c) => c.participations).filter((round) => round.investorsDisclosed);
+    const coInvestors = new Map();
+    for (const round of disclosed) {
+        for (const participant of round.participants)
+            if (participant.id !== investorId)
+                add(coInvestors, participant, 1);
+    }
+    const rankedCo = rank(coInvestors, disclosed.length);
+    return {
+        role: "descriptive",
+        note: "Context for investment leadership, not a separate measure: who led the first rounds this investor joined without leading, and who it co-invests with.",
+        lead_partners: {
+            basis: "initial_rounds_led_by_another_investor",
+            rounds: n,
+            unique_lead_partners: leads.size,
+            top_lead: rankedLeads[0] ?? null,
+            top_lead_dependence: rankedLeads[0]?.share ?? null,
+            herfindahl_index: herfindahl,
+            top: rankedLeads.slice(0, TOP_PARTNERS),
+        },
+        co_investors: {
+            basis: "all_participations_with_disclosed_investors",
+            rounds_considered: disclosed.length,
+            unique_co_investors: coInvestors.size,
+            repeat_co_investors: rankedCo.filter((partner) => partner.rounds >= 2).length,
+            top: rankedCo.slice(0, TOP_PARTNERS),
+        },
+    };
+}

package/dist/analysis/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/analyse-command.js

@@ -0,0 +1,106 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { analyse } from "../analysis/analyse.js";
+import { blackSheepScore, sheepProfile } from "../analysis/black-sheep.js";
+import { CALIBRATION } from "../analysis/black-sheep-calibration.js";
+import { latestCompleteRun, loadDataset } from "../analysis/dataset.js";
+import { loadDealroomConfig } from "../config.js";
+import { DealroomClient } from "../dealroom/client.js";
+import { extractionIsStale, openDatabase } from "../db/database.js";
+import { rebuildDerivedTables } from "../ingest/extract.js";
+import { ingestInvestor } from "../ingest/fetch.js";
+import { resolveInvestor } from "../ingest/resolve.js";
+import { buildReport, renderJson } from "../reports/json.js";
+import { renderBlackSheep } from "../reports/sheep.js";
+export class UsageError extends Error {
+    name = "UsageError";
+}
+export const SUPPORTED_FORMATS = ["sheep", "json"];
+export function openWorkingDatabase(path, log) {
+    const db = openDatabase(path);
+    if (extractionIsStale(db)) {
+        log("Stored tables come from an older extraction version; rebuilding them from stored responses");
+        rebuildDerivedTables(db);
+    }
+    return db;
+}
+export async function runAnalyse(options, io) {
+    if (options.offline && options.refresh)
+        throw new UsageError("--offline and --refresh cannot be combined.");
+    if (!SUPPORTED_FORMATS.includes(options.format)) {
+        throw new UsageError(`Unsupported --format "${options.format}". Supported: ${SUPPORTED_FORMATS.join(", ")}.`);
+    }
+    if (!options.investor && !options.investorId)
+        throw new UsageError("Give an investor name or --investor-id <uuid>.");
+    const log = (message) => io.stderr(`${message}\n`);
+    const db = openWorkingDatabase(options.db, log);
+    try {
+        let client;
+        const getClient = () => (client ??= new DealroomClient(loadDealroomConfig(io.env), { fetch: io.fetch, sleep: io.sleep, log }));
+        const resolution = await resolveInvestor({
+            db,
+            query: options.investor,
+            investorId: options.investorId,
+            offline: options.offline,
+            client: getClient,
+            choose: options.interactive && io.isInteractive ? promptChoice(log) : undefined,
+        });
+        const stored = latestCompleteRun(db, resolution.id);
+        if (options.offline) {
+            log(`Using stored data for ${resolution.name} (offline)`);
+        }
+        else if (stored === null || options.refresh) {
+            log(`${stored === null ? "Fetching" : "Refreshing"} ${resolution.name} (${resolution.id}) from Dealroom`);
+            await ingestInvestor(db, getClient(), resolution.id, { log });
+            const usage = getClient().usage;
+            log(`Fetched with ${usage.requests} requests, ${usage.credits} Dealroom credits`);
+        }
+        else {
+            log(`Using stored data for ${resolution.name} from run ${stored}; pass --refresh to fetch again`);
+        }
+        const dataset = loadDataset(db, resolution.id);
+        const analysis = analyse(dataset);
+        const blackSheep = blackSheepScore(sheepProfile(analysis.history, analysis.entryMaturity, dataset.investor.name), CALIBRATION);
+        const text = options.format === "json"
+            ? renderJson(buildReport(dataset, analysis, blackSheep, { verbose: options.verbose }))
+            : renderBlackSheep(dataset.investor.name, scoredValue(dataset.investor.name, blackSheep));
+        if (options.output) {
+            const path = resolve(options.output);
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, text);
+            log(`Wrote ${path}`);
+        }
+        else {
+            io.stdout(text);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function scoredValue(name, score) {
+    if (score.value === null) {
+        throw new UsageError(`No black sheep score for ${name}. ${score.reasons.join(" ")} Use --format json for the full report.`);
+    }
+    return score.value;
+}
+function promptChoice(log) {
+    return async (query, candidates) => {
+        log(`"${query}" matches several investors:`);
+        candidates.forEach((candidate, index) => log(`  ${index + 1}. ${describeCandidate(candidate)}`));
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            const answer = (await rl.question(`Choose 1-${candidates.length} (anything else cancels): `)).trim();
+            const index = Number(answer);
+            return Number.isInteger(index) && index >= 1 && index <= candidates.length ? candidates[index - 1] : null;
+        }
+        finally {
+            rl.close();
+        }
+    };
+}
+export function describeCandidate(candidate) {
+    const details = [candidate.domain, candidate.location].filter(Boolean).join(", ");
+    return `${candidate.name}${details ? ` (${details})` : ""}  --investor-id ${candidate.id}`;
+}