sheeply 0.0.0-stage → 0.1.0

package/dist/cli/db-command.js

@@ -0,0 +1,28 @@
+import { rebuildDerivedTables } from "../ingest/extract.js";
+import { openDatabase } from "../db/database.js";
+export function runRebuild(dbPath, io) {
+    const db = openDatabase(dbPath);
+    try {
+        const runs = rebuildDerivedTables(db);
+        io.stderr(`Rebuilt derived tables from ${runs.length} stored ingestion run(s)\n`);
+    }
+    finally {
+        db.close();
+    }
+}
+export function runStatus(dbPath, io) {
+    const db = openDatabase(dbPath);
+    try {
+        const investors = db
+            .prepare(`SELECT r.investor_id AS id, i.name, max(CASE WHEN r.status = 'complete' THEN r.id END) AS latest_run,
+           max(CASE WHEN r.status = 'complete' THEN r.finished_at END) AS retrieved_at,
+           sum(r.status = 'complete') AS complete_runs, sum(r.status = 'failed') AS failed_runs
+         FROM ingestion_runs r LEFT JOIN investors i ON i.uuid = r.investor_id
+         GROUP BY r.investor_id ORDER BY i.name, r.investor_id`)
+            .all();
+        io.stdout(`${JSON.stringify({ database: dbPath, investors }, null, 2)}\n`);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { CommanderError } from "commander";
+import { ConfigError, loadDotEnv } from "../config.js";
+import { DealroomApiError, DealroomSchemaError } from "../dealroom/client.js";
+import { InvestorResolutionError } from "../ingest/resolve.js";
+import { NoStoredDataError } from "../analysis/dataset.js";
+import { UsageError, describeCandidate } from "./analyse-command.js";
+import { buildProgram } from "./program.js";
+loadDotEnv();
+const io = {
+    env: process.env,
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+    isInteractive: Boolean(process.stdin.isTTY && process.stderr.isTTY),
+};
+try {
+    await buildProgram(io).parseAsync(process.argv);
+}
+catch (error) {
+    process.exitCode = exitCodeFor(error);
+}
+function exitCodeFor(error) {
+    if (error instanceof CommanderError)
+        return error.exitCode;
+    const message = error instanceof Error ? error.message : String(error);
+    io.stderr(`sheeply: ${message}\n`);
+    if (error instanceof InvestorResolutionError) {
+        for (const candidate of error.candidates)
+            io.stderr(`  ${describeCandidate(candidate)}\n`);
+        return 2;
+    }
+    if (error instanceof UsageError || error instanceof ConfigError || error instanceof NoStoredDataError)
+        return 2;
+    if (error instanceof DealroomApiError || error instanceof DealroomSchemaError)
+        return 3;
+    if (error instanceof Error && error.stack && process.env.SHEEPLY_DEBUG)
+        io.stderr(`${error.stack}\n`);
+    return 1;
+}

package/dist/cli/program.js

@@ -0,0 +1,38 @@
+import { Command, Option } from "commander";
+import { DEFAULT_DB_PATH } from "../config.js";
+import { TOOL_VERSION } from "../version.js";
+import { SUPPORTED_FORMATS, runAnalyse } from "./analyse-command.js";
+import { runRebuild, runStatus } from "./db-command.js";
+export function buildProgram(io) {
+    const dbDefault = io.env.SHEEPLY_DB || DEFAULT_DB_PATH;
+    const dbOption = () => new Option("--db <path>", "SQLite cache file, created if missing").default(dbDefault);
+    const program = new Command()
+        .name("sheeply")
+        .description("Profile how a venture firm invests (entry stage, lead behaviour, syndicates) from Dealroom data.")
+        .version(TOOL_VERSION)
+        .enablePositionalOptions()
+        .argument("[investor]", "investor name to resolve on Dealroom")
+        .option("--investor-id <uuid>", "Dealroom investor UUID, skips name resolution")
+        .addOption(dbOption())
+        .option("--refresh", "fetch from Dealroom again even if data is stored", false)
+        .option("--offline", "use only stored data, never call Dealroom", false)
+        .addOption(new Option("--format <format>", "output format").choices(SUPPORTED_FORMATS).default("sheep"))
+        .option("--output <file>", "write the report to a file instead of stdout")
+        .option("--verbose", "include the per-company investments behind every metric (json format)", false)
+        .option("--no-interactive", "fail instead of prompting when a name is ambiguous")
+        .configureOutput({ writeOut: io.stdout, writeErr: io.stderr })
+        .exitOverride()
+        .action(async (investor, options) => {
+        await runAnalyse({ ...options, investor }, io);
+    });
+    const db = program.command("db").description("Manage the local SQLite cache");
+    db.command("rebuild")
+        .description("Drop and re-derive every table from the stored Dealroom responses (no API calls)")
+        .addOption(dbOption())
+        .action((options) => runRebuild(options.db, io));
+    db.command("status")
+        .description("List stored investors and ingestion runs")
+        .addOption(dbOption())
+        .action((options) => runStatus(options.db, io));
+    return program;
+}

package/dist/config.js

@@ -0,0 +1,53 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseEnv } from "node:util";
+export const DEALROOM_DEFAULTS = {
+    baseUrl: "https://api.dealroom.app",
+    tokenUrl: "https://accounts.dealroom.co/oauth/token",
+    apiVersion: "2026-10-22",
+    requestsPerSecond: 4,
+    timeoutMs: 60_000,
+    maxRetries: 5,
+};
+export const DEFAULT_DB_PATH = "sheeply.sqlite";
+export class ConfigError extends Error {
+    name = "ConfigError";
+}
+/** Fills unset variables from `.env` in the working directory; real environment values always win. */
+export function loadDotEnv(cwd = process.cwd(), env = process.env) {
+    const file = resolve(cwd, ".env");
+    if (!existsSync(file))
+        return;
+    for (const [key, value] of Object.entries(parseEnv(readFileSync(file, "utf8")))) {
+        if (env[key] === undefined || env[key] === "")
+            env[key] = value;
+    }
+}
+const positiveNumber = (raw, fallback, name) => {
+    if (raw === undefined || raw === "")
+        return fallback;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0)
+        throw new ConfigError(`${name} must be a positive number, got "${raw}"`);
+    return value;
+};
+export function loadDealroomConfig(env = process.env) {
+    const clientId = env.DEALROOM_CLIENT_ID ?? "";
+    const clientSecret = env.DEALROOM_CLIENT_SECRET ?? "";
+    if (!clientId || !clientSecret) {
+        throw new ConfigError("DEALROOM_CLIENT_ID and DEALROOM_CLIENT_SECRET are required to fetch from Dealroom. " +
+            "Copy .env.example to .env and fill them in, or rerun with --offline to use stored data.");
+    }
+    const baseUrl = (env.DEALROOM_API_BASE_URL || DEALROOM_DEFAULTS.baseUrl).replace(/\/+$/, "");
+    return {
+        clientId,
+        clientSecret,
+        baseUrl,
+        audience: env.DEALROOM_AUDIENCE || baseUrl,
+        tokenUrl: env.DEALROOM_TOKEN_URL || DEALROOM_DEFAULTS.tokenUrl,
+        apiVersion: env.DEALROOM_API_VERSION || DEALROOM_DEFAULTS.apiVersion,
+        requestsPerSecond: positiveNumber(env.DEALROOM_REQUESTS_PER_SECOND, DEALROOM_DEFAULTS.requestsPerSecond, "DEALROOM_REQUESTS_PER_SECOND"),
+        timeoutMs: positiveNumber(env.DEALROOM_TIMEOUT_MS, DEALROOM_DEFAULTS.timeoutMs, "DEALROOM_TIMEOUT_MS"),
+        maxRetries: DEALROOM_DEFAULTS.maxRetries,
+    };
+}

package/dist/db/database.js

@@ -0,0 +1,53 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { EXTRACTION_VERSION } from "../version.js";
+import { DERIVED_SCHEMA, DERIVED_TABLES, MIGRATIONS } from "./schema.js";
+export function openDatabase(path) {
+    if (path !== ":memory:")
+        mkdirSync(dirname(path), { recursive: true });
+    const db = new DatabaseSync(path);
+    db.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+    migrate(db);
+    return db;
+}
+function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY, applied_at TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+  `);
+    const applied = new Set(db.prepare("SELECT version FROM schema_migrations").all().map((row) => Number(row.version)));
+    for (const migration of MIGRATIONS) {
+        if (applied.has(migration.version))
+            continue;
+        transaction(db, () => {
+            db.exec(migration.sql);
+            db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)").run(migration.version, new Date().toISOString());
+        });
+    }
+    db.exec(DERIVED_SCHEMA);
+}
+/** True when derived tables were produced by an older extraction and need a rebuild. */
+export function extractionIsStale(db) {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'extraction_version'").get();
+    const hasRuns = db.prepare("SELECT 1 FROM ingestion_runs WHERE status = 'complete' LIMIT 1").get() !== undefined;
+    return hasRuns && row?.value !== EXTRACTION_VERSION;
+}
+export function resetDerivedTables(db) {
+    for (const table of DERIVED_TABLES)
+        db.exec(`DROP TABLE IF EXISTS ${table}`);
+    db.exec(DERIVED_SCHEMA);
+    db.prepare("INSERT INTO meta (key, value) VALUES ('extraction_version', ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value").run(EXTRACTION_VERSION);
+}
+export function transaction(db, fn) {
+    db.exec("BEGIN");
+    try {
+        const result = fn();
+        db.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}

package/dist/db/schema.js

@@ -0,0 +1,159 @@
+/**
+ * Two layers. `ingestion_runs` and `raw_responses` record exactly what Dealroom returned and when.
+ * Every other table is derived from them by src/ingest/extract.ts and can be dropped and rebuilt
+ * at any time (`sheeply db rebuild`), so it is never the source of truth.
+ */
+export const MIGRATIONS = [
+    {
+        version: 1,
+        sql: `
+      CREATE TABLE ingestion_runs (
+        id INTEGER PRIMARY KEY,
+        investor_id TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('running', 'complete', 'failed')),
+        started_at TEXT NOT NULL,
+        finished_at TEXT,
+        api_base_url TEXT NOT NULL,
+        api_version TEXT NOT NULL,
+        rounds_strategy TEXT,
+        tool_version TEXT NOT NULL,
+        requests INTEGER,
+        credits_used INTEGER,
+        error TEXT
+      );
+      CREATE INDEX ingestion_runs_investor ON ingestion_runs (investor_id, status, id);
+
+      CREATE TABLE raw_responses (
+        id INTEGER PRIMARY KEY,
+        run_id INTEGER NOT NULL REFERENCES ingestion_runs (id) ON DELETE CASCADE,
+        kind TEXT NOT NULL CHECK (kind IN ('investor', 'portfolio', 'transactions', 'company_rounds')),
+        subject_id TEXT NOT NULL,
+        page_index INTEGER NOT NULL,
+        endpoint TEXT NOT NULL,
+        params_json TEXT NOT NULL,
+        retrieved_at TEXT NOT NULL,
+        api_version TEXT,
+        credits_used INTEGER,
+        body_sha256 TEXT NOT NULL,
+        body_json TEXT NOT NULL
+      );
+      CREATE INDEX raw_responses_run ON raw_responses (run_id, kind, subject_id, page_index);
+    `,
+    },
+];
+export const DERIVED_TABLES = [
+    "round_participants",
+    "investor_round_scope",
+    "funding_rounds",
+    "company_taxonomy",
+    "taxonomy_terms",
+    "portfolio_relationships",
+    "companies",
+    "investors",
+    "entities",
+    "extraction_state",
+];
+export const DERIVED_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS entities (
+    uuid TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL,
+    subtype TEXT,
+    dealroom_url TEXT,
+    source_response_id INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS investors (
+    uuid TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    name_key TEXT NOT NULL,
+    type TEXT NOT NULL,
+    subtype TEXT,
+    firm_types_json TEXT NOT NULL,
+    launch_date TEXT,
+    domain TEXT,
+    hq_country TEXT,
+    dealroom_url TEXT,
+    reported_portfolio_total INTEGER,
+    reported_rounds_count INTEGER,
+    source_response_id INTEGER NOT NULL,
+    retrieved_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS investors_name_key ON investors (name_key);
+
+  CREATE TABLE IF NOT EXISTS companies (
+    uuid TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    subtype TEXT,
+    launch_date TEXT,
+    dealroom_url TEXT,
+    taxonomy_known INTEGER NOT NULL,
+    source_response_id INTEGER NOT NULL,
+    retrieved_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS taxonomy_terms (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS company_taxonomy (
+    company_id TEXT NOT NULL,
+    term_id INTEGER NOT NULL,
+    source_response_id INTEGER NOT NULL,
+    PRIMARY KEY (company_id, term_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS portfolio_relationships (
+    investor_id TEXT NOT NULL,
+    company_id TEXT NOT NULL,
+    company_subtype TEXT,
+    is_lead_any INTEGER NOT NULL,
+    rounds_count INTEGER NOT NULL,
+    last_round_date TEXT,
+    source_response_id INTEGER NOT NULL,
+    retrieved_at TEXT NOT NULL,
+    PRIMARY KEY (investor_id, company_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS funding_rounds (
+    id INTEGER PRIMARY KEY,
+    company_id TEXT NOT NULL,
+    announced_date TEXT,
+    round_type TEXT,
+    standardized_round TEXT,
+    round_label TEXT,
+    amount REAL,
+    valuation REAL,
+    currency TEXT,
+    is_vc_round INTEGER,
+    is_exit INTEGER,
+    investors_disclosed INTEGER NOT NULL,
+    source_url TEXT,
+    source_response_id INTEGER NOT NULL,
+    retrieved_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS funding_rounds_company ON funding_rounds (company_id);
+
+  CREATE TABLE IF NOT EXISTS round_participants (
+    round_id INTEGER NOT NULL,
+    entity_id TEXT NOT NULL,
+    is_lead INTEGER,
+    position INTEGER NOT NULL,
+    PRIMARY KEY (round_id, entity_id)
+  );
+  CREATE INDEX IF NOT EXISTS round_participants_entity ON round_participants (entity_id);
+
+  CREATE TABLE IF NOT EXISTS investor_round_scope (
+    investor_id TEXT NOT NULL,
+    round_id INTEGER NOT NULL,
+    PRIMARY KEY (investor_id, round_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS extraction_state (
+    investor_id TEXT PRIMARY KEY,
+    run_id INTEGER NOT NULL,
+    extraction_version TEXT NOT NULL
+  );
+`;

package/dist/dealroom/client.js

@@ -0,0 +1,208 @@
+import { TOOL_NAME, TOOL_VERSION } from "../version.js";
+import { errorEnvelope } from "./schemas.js";
+export class DealroomApiError extends Error {
+    name = "DealroomApiError";
+    status;
+    code;
+    endpoint;
+    constructor(message, status, code, endpoint) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.endpoint = endpoint;
+    }
+}
+export class DealroomSchemaError extends Error {
+    name = "DealroomSchemaError";
+    endpoint;
+    issues;
+    constructor(endpoint, issues) {
+        super(`Unexpected response shape from ${endpoint}: ${issues.slice(0, 5).join("; ")}`);
+        this.endpoint = endpoint;
+        this.issues = issues;
+    }
+}
+const TOKEN_EXPIRY_SKEW_MS = 60_000;
+const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class DealroomClient {
+    config;
+    #fetch;
+    #sleep;
+    #now;
+    #log;
+    #token = null;
+    #nextSlot = 0;
+    #requests = 0;
+    #credits = 0;
+    #warnedVersion = false;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.#fetch = options.fetch ?? fetch;
+        this.#sleep = options.sleep ?? defaultSleep;
+        this.#now = options.now ?? Date.now;
+        this.#log = options.log ?? (() => { });
+    }
+    get usage() {
+        return { requests: this.#requests, credits: this.#credits };
+    }
+    async getValidated(endpoint, params, schema) {
+        const { body, meta } = await this.get(endpoint, params);
+        const parsed = schema.safeParse(body);
+        if (!parsed.success) {
+            throw new DealroomSchemaError(endpoint, parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`));
+        }
+        return { body: parsed.data, meta, raw: body };
+    }
+    async get(endpoint, params = {}) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined)
+                query.set(key, String(value));
+        }
+        const url = `${this.config.baseUrl}${endpoint}${query.size ? `?${query}` : ""}`;
+        for (let attempt = 0;; attempt++) {
+            await this.#takeSlot();
+            const token = await this.#getToken();
+            let response;
+            try {
+                this.#requests++;
+                response = await this.#fetch(url, {
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        "X-Client-Id": this.config.clientId,
+                        "API-Version": this.config.apiVersion,
+                        "User-Agent": `${TOOL_NAME}/${TOOL_VERSION}`,
+                        Accept: "application/json",
+                    },
+                    signal: AbortSignal.timeout(this.config.timeoutMs),
+                });
+            }
+            catch (cause) {
+                if (attempt < this.config.maxRetries) {
+                    const wait = this.#backoff(attempt);
+                    this.#log(`network error on ${endpoint} (${describe(cause)}), retrying in ${wait}ms`);
+                    await this.#sleep(wait);
+                    continue;
+                }
+                throw new DealroomApiError(`Network failure on ${endpoint}: ${describe(cause)}`, 0, "NETWORK_ERROR", endpoint);
+            }
+            const credits = Number(response.headers.get("X-Credits-Used"));
+            if (Number.isFinite(credits))
+                this.#credits += credits;
+            if (response.ok) {
+                const text = await response.text();
+                let body;
+                try {
+                    body = JSON.parse(text);
+                }
+                catch {
+                    if (attempt < this.config.maxRetries) {
+                        await this.#sleep(this.#backoff(attempt));
+                        continue;
+                    }
+                    throw new DealroomApiError(`Non-JSON 200 response from ${endpoint}`, response.status, "INVALID_BODY", endpoint);
+                }
+                const meta = {
+                    endpoint,
+                    params: Object.fromEntries(query.entries()),
+                    status: response.status,
+                    apiVersion: response.headers.get("API-Version"),
+                    creditsUsed: Number.isFinite(credits) ? credits : null,
+                    retrievedAt: new Date(this.#now()).toISOString(),
+                    deprecation: response.headers.get("Deprecation"),
+                    sunset: response.headers.get("Sunset"),
+                };
+                if (meta.sunset && !this.#warnedVersion) {
+                    this.#warnedVersion = true;
+                    this.#log(`API version ${this.config.apiVersion} is deprecated and sunsets on ${meta.sunset}`);
+                }
+                return { body, meta };
+            }
+            const text = await response.text();
+            const code = parseErrorCode(text);
+            if (response.status === 401 && attempt === 0) {
+                this.#token = null;
+                continue;
+            }
+            if (RETRYABLE_STATUS.has(response.status) && attempt < this.config.maxRetries) {
+                const retryAfter = Number(response.headers.get("Retry-After"));
+                const wait = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : this.#backoff(attempt);
+                this.#log(`${response.status} ${code} on ${endpoint}, retrying in ${wait}ms`);
+                await this.#sleep(wait);
+                continue;
+            }
+            throw new DealroomApiError(explain(response.status, code, endpoint, text), response.status, code, endpoint);
+        }
+    }
+    #backoff(attempt) {
+        return Math.min(30_000, 500 * 2 ** attempt);
+    }
+    async #takeSlot() {
+        const interval = Math.ceil(1000 / this.config.requestsPerSecond);
+        const now = this.#now();
+        const slot = Math.max(now, this.#nextSlot);
+        this.#nextSlot = slot + interval;
+        if (slot > now)
+            await this.#sleep(slot - now);
+    }
+    async #getToken() {
+        if (this.#token && this.#token.expiresAt > this.#now())
+            return this.#token.value;
+        let response;
+        try {
+            response = await this.#fetch(this.config.tokenUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "User-Agent": `${TOOL_NAME}/${TOOL_VERSION}` },
+                body: JSON.stringify({
+                    client_id: this.config.clientId,
+                    client_secret: this.config.clientSecret,
+                    audience: this.config.audience,
+                    grant_type: "client_credentials",
+                }),
+                signal: AbortSignal.timeout(this.config.timeoutMs),
+            });
+        }
+        catch (cause) {
+            throw new DealroomApiError(`Token exchange failed: ${describe(cause)}`, 0, "NETWORK_ERROR", "oauth/token");
+        }
+        if (!response.ok) {
+            const hint = response.status === 403
+                ? ` The key was refused for audience ${this.config.audience}. Keys issued for the beta host need DEALROOM_API_BASE_URL=https://api.beta.dealroom.app.`
+                : "";
+            throw new DealroomApiError(`Token exchange failed with ${response.status}.${hint}`, response.status, "AUTH_FAILED", "oauth/token");
+        }
+        const body = (await response.json());
+        if (!body.access_token)
+            throw new DealroomApiError("Token exchange returned no access_token", 200, "AUTH_FAILED", "oauth/token");
+        this.#token = {
+            value: body.access_token,
+            expiresAt: this.#now() + (body.expires_in ?? 3600) * 1000 - TOKEN_EXPIRY_SKEW_MS,
+        };
+        return body.access_token;
+    }
+}
+function parseErrorCode(text) {
+    try {
+        const parsed = errorEnvelope.safeParse(JSON.parse(text));
+        return parsed.success ? parsed.data.error.code : "UNKNOWN";
+    }
+    catch {
+        return "UNKNOWN";
+    }
+}
+function explain(status, code, endpoint, text) {
+    const detail = text.trimStart().startsWith("<") ? "(HTML error page)" : text.slice(0, 300);
+    if (status === 402)
+        return `Dealroom credits are exhausted (402 ${code}) on ${endpoint}. Add credits before retrying.`;
+    if (status === 403)
+        return `Dealroom refused ${endpoint} (403 ${code}): the API key lacks access. ${detail}`;
+    if (status === 404)
+        return `Not found on Dealroom: ${endpoint} (404 ${code})`;
+    return `${status} ${code} on ${endpoint}: ${detail}`;
+}
+function describe(cause) {
+    if (cause instanceof Error)
+        return cause.name === "TimeoutError" ? "timed out" : cause.message;
+    return String(cause);
+}

package/dist/dealroom/endpoints.js

@@ -0,0 +1,17 @@
+import { walkPages } from "./pagination.js";
+import { companyRoundsResponse, investorDetailResponse, portfolioResponse, searchResponse, transactionsResponse, } from "./schemas.js";
+export const PORTFOLIO_PAGE_SIZE = 500;
+export const TRANSACTIONS_PAGE_SIZE = 500;
+export const COMPANY_ROUNDS_PAGE_SIZE = 500;
+export const SEARCH_LIMIT = 20;
+export const searchInvestors = (client, query) => client.getValidated("/data/search", { q: query, types: "investor", limit: SEARCH_LIMIT }, searchResponse);
+export const getInvestor = (client, id) => client.getValidated(`/data/investors/${encodeURIComponent(id)}`, {}, investorDetailResponse);
+export const portfolioPages = (client, id) => walkPages(client, `/data/investors/${encodeURIComponent(id)}/portfolio`, { limit: PORTFOLIO_PAGE_SIZE }, portfolioResponse);
+/** Every round of every company the investor has backed, including rounds it did not join. */
+export const portfolioTransactionPages = (client, id) => walkPages(client, "/data/transactions", {
+    filter: `company_investor_id[in_any]:${id}`,
+    sort: "date",
+    limit: TRANSACTIONS_PAGE_SIZE,
+    include_total: true,
+}, transactionsResponse);
+export const companyRoundPages = (client, companyId) => walkPages(client, `/data/companies/${encodeURIComponent(companyId)}/funding-rounds`, { limit: COMPANY_ROUNDS_PAGE_SIZE }, companyRoundsResponse);

package/dist/dealroom/pagination.js

@@ -0,0 +1,25 @@
+import { DealroomApiError } from "./client.js";
+const MAX_PAGES = 10_000;
+/**
+ * Walks a `/data` list by cursor. The first request carries `limit`; later ones send the cursor
+ * back with the same `filter` and `sort`, which the API requires to match the cursor's origin.
+ */
+export async function* walkPages(client, endpoint, params, schema) {
+    const carried = { filter: params.filter, sort: params.sort, currency: params.currency };
+    const seen = new Set();
+    let cursor = null;
+    for (let pageIndex = 0; pageIndex < MAX_PAGES; pageIndex++) {
+        const request = cursor === null ? params : { ...carried, cursor };
+        const response = await client.getValidated(endpoint, request, schema);
+        yield { ...response, pageIndex };
+        const next = response.body.page.next_cursor ?? null;
+        if (next === null || response.body.data.length === 0)
+            return;
+        if (seen.has(next)) {
+            throw new DealroomApiError(`Pagination on ${endpoint} returned a repeated cursor`, 200, "PAGINATION_LOOP", endpoint);
+        }
+        seen.add(next);
+        cursor = next;
+    }
+    throw new DealroomApiError(`Pagination on ${endpoint} exceeded ${MAX_PAGES} pages`, 200, "PAGINATION_LIMIT", endpoint);
+}