@bigsteele/the-prospect 0.1.1 → 0.2.0

package/dist/cli.js

@@ -86,7 +86,29 @@ async function main() {
             stdio: "inherit",
             shell: false,
         });
-        return new Promise((res) => child.on("exit", (c) => res(c ?? 0)));
+        // THE SUBPROCESS IS A CONVENIENCE, NOT THE PROTOCOL (0.2). Spawning `claude`
+        // couples this package to whatever version is installed, and on 2026-09-13
+        // that failed outright: "Claude Code 2.1.22 does not support this model;
+        // version 2.1.251 or newer is required". A blank error and no research.
+        //
+        // The protocol is a file. Any agent that can read it and search the web can
+        // run it, so a failure here names the file rather than ending the road.
+        child.on("error", () => {
+            log("");
+            log("Could not start Claude Code. It may not be installed, or may be too old.");
+            log(`The protocol is a file, and nothing here depends on that binary:`);
+            log(`  ${protocol}`);
+            log("Open it in any agent that can read your repository and search the web.");
+        });
+        return new Promise((res) => child.on("exit", (c) => {
+            if (c !== 0) {
+                log("");
+                log(`Research did not complete. The protocol is at ${protocol} and can be run by hand:`);
+                log(`  read the-prospect-<app>.json, then follow its six steps.`);
+                log(`If Claude Code reported a version error, \`claude update\` and try again.`);
+            }
+            res(c ?? 0);
+        }));
     }
     const p = await runProspect(repoDir);
     const leak = secretShaped(p);

package/dist/decisions.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The decision record: what the repository says it decided, read before the
+ * scan reports what it built.
+ *
+ * WHY THIS EXISTS. The Big Sean reads the decision record and reports the
+ * difference between what a repository says and what it does. The Prospect
+ * read no `.md` at all - the ledger listed 415 of them as unclaimed on the first
+ * real repository, and the reasoning that explains the code sat in every one
+ * of them. So a copy inlined on purpose (decision 8: generated code lives in
+ * the customer's repo and cannot import from ours), a second hosting vendor
+ * kept on purpose (decision 19), and a dependency loaded by name all reported
+ * as drift, and all deducted.
+ *
+ * A subtract finding is a finding only when NO recorded decision explains it.
+ * What the record explains is listed as on record - the reader sees the tool
+ * looked, and the score does not charge for a choice somebody made and wrote
+ * down. That is the same rule The Big Sean applies to its own checks: "record
+ * that in DECISIONS.md and leave the check FAIL honestly".
+ *
+ * WHAT COUNTS AS THE RECORD. Files a person wrote to explain choices:
+ * DECISIONS.md and its variants, CLAUDE.md and AGENTS.md (instructions to an
+ * agent are decisions by another name), ADR trees, a `.planning/` directory,
+ * PITFALLS.md, and a prior Big Sean run under `.planning/launch-audit/`. Not
+ * README.md - that is what the product says to buyers, and the North Star reads
+ * it separately. Not `docs/` wholesale - most of it is reference, and a match in
+ * a runbook proves a term was mentioned, not that a choice was made.
+ */
+import type { Repo } from "./walk.js";
+export interface Citation {
+    file: string;
+    line: number;
+    /** The matching line, trimmed to fit a table cell. */
+    excerpt: string;
+}
+export interface DecisionRecord {
+    /** Files read as the record, repository-relative. */
+    files: string[];
+    /** Entries indexed: one per non-empty line. */
+    entries: number;
+    /**
+     * From a prior Big Sean run, when one exists: the workflows the business dies
+     * without, in its order. Used to say which one a finding touches.
+     */
+    critical_few: string[];
+}
+export declare const DECISION_FILES: RegExp;
+export declare class Decisions {
+    private entries;
+    readonly files: string[];
+    readonly critical_few: string[];
+    static read(repo: Repo): Promise<Decisions>;
+    /**
+     * The Big Sean's "critical few" list, when it left one. It is a numbered list
+     * under that heading; the first clause of each item is the workflow's name.
+     */
+    private readCriticalFew;
+    /**
+     * The entry that DECIDES about a subject, or null. A mention is not a decision.
+     *
+     * The first version returned the first line anywhere in the record containing
+     * the word, and on a repository with 8,000 lines of planning notes that cited
+     * "hand-rolled search" to a line about invoice search, `session.ts` to "the
+     * Session pooler URL" and `shell.tsx` to "shell export". The family's oldest
+     * lesson - a name appearing is not the thing being used - arriving inside the
+     * reader written to apply it.
+     *
+     * Three rules, and an entry needs to clear them, not merely match:
+     *
+     *   - WHERE it is said. A row of DECISIONS.md, an ADR, or a rule in CLAUDE.md
+     *     is a decision by construction. A line in a checkpoint queue or a status
+     *     file is context, and counts only when it also SAYS it is deciding.
+     *   - HOW it is said. Outside a decision file, the entry must carry a decision
+     *     word: decided, keep, on purpose, by design, deliberately, chosen, we use.
+     *   - WHAT it names. A pair (two vendors, a kept-and-questioned platform) is
+     *     decided by an entry naming BOTH. A generic file stem - session, shell,
+     *     route, consent, index - is never matched as a bare word; the caller
+     *     passes a path fragment instead.
+     */
+    explains(subjects: string[], opts?: {
+        all?: boolean;
+    }): Citation | null;
+    toJSON(): DecisionRecord;
+}
+/**
+ * Which workflow a path touches - a HEURISTIC, and named as one in the report.
+ *
+ * The Big Sean derives the critical few from the code and the live system, and
+ * every finding it prints says which one it protects. A static scan cannot
+ * derive them, but it can read the path: a file under `billing/` is on the
+ * money path whatever else is true of it. When a prior Big Sean run left its
+ * list, the names come from there; otherwise these are the generic five.
+ */
+export declare function touches(path: string, criticalFew: string[]): string;

package/dist/decisions.js

@@ -0,0 +1,143 @@
+export const DECISION_FILES = /(^|\/)(DECISIONS?|DECISION-LOG|DECISION-REQUESTS?|CLAUDE|AGENTS|PITFALLS|ARCHITECTURE|CONVENTIONS)\.md$|(^|\/)(adr|adrs|decisions)\/[^/]+\.md$|^\.planning\/[^/]+\.md$|^\.planning\/launch-audit\/[^/]+\.md$|^docs\/adr\/[^/]+\.md$/i;
+/** Files that ARE the decision record, as opposed to planning notes that may hold one. */
+const DECISION_PROPER = /(^|\/)(DECISIONS?|DECISION-LOG|CLAUDE|AGENTS|ARCHITECTURE|CONVENTIONS)\.md$|(^|\/)(adr|adrs|decisions)\/[^/]+\.md$|^docs\/adr\/[^/]+\.md$/i;
+/** The words a line uses when it is deciding rather than describing. */
+const DECISION_WORDS = /\b(decided|decision|we (keep|use|chose|run|host)|keep(s|ing)? (it|this|both)|kept|on purpose|deliberate(ly)?|by design|chosen|default(s)? to|stays?\b|do not remove|never imported|copied from)\b/i;
+/** File stems too common to match as a bare word. The caller passes a path fragment. */
+const GENERIC_STEM = /^(session|shell|route|routes|consent|bridge|index|main|app|utils?|config|types?|client|server|handler|grant|mount|events?|api|lib|core|common|base|helpers?|store|state|auth|user|users|data|model|models|service|services|page|pages|layout|search|report|egress)$/i;
+export class Decisions {
+    entries = [];
+    files = [];
+    critical_few = [];
+    static async read(repo) {
+        const d = new Decisions();
+        for (const f of repo.files.filter((x) => DECISION_FILES.test(x))) {
+            const text = await repo.read(f);
+            if (!text)
+                continue;
+            d.files.push(f);
+            text.split("\n").forEach((raw, i) => {
+                const t = raw.trim();
+                if (t.length < 12)
+                    return;
+                d.entries.push({ file: f, line: i + 1, text: t, lower: t.toLowerCase() });
+            });
+        }
+        d.readCriticalFew();
+        return d;
+    }
+    /**
+     * The Big Sean's "critical few" list, when it left one. It is a numbered list
+     * under that heading; the first clause of each item is the workflow's name.
+     */
+    readCriticalFew() {
+        const inList = { on: false, file: "" };
+        for (const e of this.entries) {
+            if (/^#{1,4}\s+the critical few/i.test(e.text)) {
+                inList.on = true;
+                inList.file = e.file;
+                continue;
+            }
+            if (!inList.on || e.file !== inList.file)
+                continue;
+            if (/^#{1,4}\s/.test(e.text))
+                break;
+            const m = /^\d+\.\s+\*\*([^*]+)\*\*/.exec(e.text);
+            if (m)
+                this.critical_few.push(m[1].trim());
+        }
+    }
+    /**
+     * The entry that DECIDES about a subject, or null. A mention is not a decision.
+     *
+     * The first version returned the first line anywhere in the record containing
+     * the word, and on a repository with 8,000 lines of planning notes that cited
+     * "hand-rolled search" to a line about invoice search, `session.ts` to "the
+     * Session pooler URL" and `shell.tsx` to "shell export". The family's oldest
+     * lesson - a name appearing is not the thing being used - arriving inside the
+     * reader written to apply it.
+     *
+     * Three rules, and an entry needs to clear them, not merely match:
+     *
+     *   - WHERE it is said. A row of DECISIONS.md, an ADR, or a rule in CLAUDE.md
+     *     is a decision by construction. A line in a checkpoint queue or a status
+     *     file is context, and counts only when it also SAYS it is deciding.
+     *   - HOW it is said. Outside a decision file, the entry must carry a decision
+     *     word: decided, keep, on purpose, by design, deliberately, chosen, we use.
+     *   - WHAT it names. A pair (two vendors, a kept-and-questioned platform) is
+     *     decided by an entry naming BOTH. A generic file stem - session, shell,
+     *     route, consent, index - is never matched as a bare word; the caller
+     *     passes a path fragment instead.
+     */
+    explains(subjects, opts = {}) {
+        const terms = subjects
+            .map((s) => s.toLowerCase().trim())
+            .filter((s) => s.length >= 4 && !GENERIC_STEM.test(s))
+            .map((s) => new RegExp(`(^|[^a-z0-9_/-])${s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^a-z0-9_-]|$)`));
+        if (terms.length === 0)
+            return null;
+        const need = opts.all ? terms.length : 1;
+        let best = null;
+        for (const e of this.entries) {
+            const hits = terms.filter((re) => re.test(e.lower)).length;
+            if (hits < need)
+                continue;
+            const inDecisionFile = DECISION_PROPER.test(e.file);
+            const decides = DECISION_WORDS.test(e.lower);
+            // A decision file's table rows and headings are decisions; its prose still
+            // has to say so. Outside a decision file, only a line that says so counts.
+            const structural = /^\|/.test(e.text) || /^#{1,4}\s/.test(e.text) || /^\d+\.\s/.test(e.text) || /^[-*]\s/.test(e.text);
+            let strength = 0;
+            if (inDecisionFile && (structural || decides))
+                strength = 3;
+            else if (decides)
+                strength = 2;
+            if (strength === 0)
+                continue;
+            if (!best || strength > best.strength)
+                best = { e, strength };
+            if (strength === 3)
+                break;
+        }
+        if (!best)
+            return null;
+        const t = best.e.text;
+        return { file: best.e.file, line: best.e.line, excerpt: t.length > 140 ? `${t.slice(0, 137)}...` : t };
+    }
+    toJSON() {
+        return { files: this.files, entries: this.entries.length, critical_few: this.critical_few };
+    }
+}
+/**
+ * Which workflow a path touches - a HEURISTIC, and named as one in the report.
+ *
+ * The Big Sean derives the critical few from the code and the live system, and
+ * every finding it prints says which one it protects. A static scan cannot
+ * derive them, but it can read the path: a file under `billing/` is on the
+ * money path whatever else is true of it. When a prior Big Sean run left its
+ * list, the names come from there; otherwise these are the generic five.
+ */
+export function touches(path, criticalFew) {
+    const p = path.toLowerCase();
+    const pick = (re, generic) => {
+        if (!re.test(p))
+            return null;
+        const named = criticalFew.find((c) => re.test(c.toLowerCase()));
+        return named ?? generic;
+    };
+    // The path regex reads the FILE; the name regex reads the Big Sean's list. They
+    // differ because a workflow is named for what it does ("Turn a repository into
+    // a harness") and a path for where it lives (adapters/, generators/).
+    const pickBy = (pathRe, nameRe, generic) => {
+        if (!pathRe.test(p))
+            return null;
+        return criticalFew.find((c) => nameRe.test(c.toLowerCase())) ?? generic;
+    };
+    return (pickBy(/billing|invoice|charge|checkout|payment|dunning|ledger|meter|subscription/, /charge|bill|invoice|meter|pay|revenue|money/, "the money path") ??
+        pickBy(/session|mint|grant|jwks|token|auth|sign-?in|login/, /session|mint|grant|sign|auth|login/, "sign-in and the session") ??
+        pickBy(/migration|rls|policy|tenant|tenancy|isolation/, /tenant|isolat|data away|rls|leak/, "keeping one tenant's data from another") ??
+        pickBy(/adapters?|templates?|generators?|shells?|ingest|\.tmpl$/, /harness|repositor|ingest|generat|adapter|ship/, "what ships into a customer's repository") ??
+        pickBy(/console|landing|pages?\/|components?\/|\.tsx$/, /console|surface|page|screen|ui\b/, "the surface a person uses") ??
+        pickBy(/ops|guard|health|digest|cron|schedule|alert|monitor/, /alert|page|break|monitor|health|uptime/, "knowing when something breaks") ??
+        "no critical workflow this scan can name");
+}

package/dist/detect/costs.js

@@ -1,4 +1,4 @@
-import { runtimeCode } from "../walk.js";
+import { scopeFor } from "../walk.js";
 const PAID_CALL = /\bfetch\(\s*[`"']https?:\/\/(api\.openai\.com|api\.anthropic\.com|generativelanguage\.googleapis\.com|api\.stripe\.com|api\.twilio\.com|api\.resend\.com|api\.sendgrid\.com|api\.cloudflare\.com|api\.replicate\.com|api\.elevenlabs\.io)|\.(messages|completions|chat|embeddings|images)\.create\(|generateContent|\.send(Email|Mail|Sms)?\(/;
 const LOOP_HEAD = /\bfor(\s+await)?\s*\(|\bwhile\s*\(|\.(map|forEach)\(\s*(async\b|\()/;
 const HANDLER = /(^|\/)(functions|api|routes?|handlers?)\//i;
@@ -12,7 +12,7 @@ function hostOrCall(line) {
 }
 export async function detectCosts(repo) {
     const out = [];
-    for (const f of runtimeCode(repo.files)) {
+    for (const f of scopeFor(repo.files, "implementation")) {
         const text = await repo.read(f);
         if (!text || !PAID_CALL.test(text))
             continue;

package/dist/detect/database.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The database, which no question used to claim.
+ *
+ * The coverage ledger's `unclaimed` list is what surfaced this: 146 `.sql` files
+ * on the first real repository the scan met, holding 243 SECURITY DEFINER
+ * functions, 82 policies and 81 tables, analysed by nothing. The absence of a
+ * detector is invisible from inside the detectors, which is why it took a ledger
+ * to notice rather than a reading of the code.
+ *
+ * It matters more than the count suggests. On a Postgres-backed product the
+ * authorisation model does not live in the application - it lives in row-level
+ * security and in who may execute a definer function. A scan that reads every
+ * line of TypeScript and no line of SQL has read the part that asks permission
+ * and skipped the part that grants it.
+ *
+ * WHAT THIS IS NOT. Not a linter, and not a security review: it runs nothing,
+ * connects to nothing, and cannot see a migration that was applied by hand and
+ * never committed. It reads the migrations as text and reports three shapes that
+ * are worth a human minute, each one a question with a subject.
+ *
+ * THE COUNTS ARE PART OF THE FINDING. `tables`, `policies` and `definer_functions`
+ * ride alongside, because "no findings" and "never looked" must not read alike -
+ * a check that reports the same whether it works or not is the failure this
+ * whole version is about.
+ */
+import type { Repo } from "../walk.js";
+import type { DatabaseReading } from "./types.js";
+export declare function detectDatabase(repo: Repo): Promise<DatabaseReading>;

package/dist/detect/database.js

@@ -0,0 +1,173 @@
+import { scopeFor } from "../walk.js";
+/**
+ * Strip comments so a shape quoted in prose is not read as a declaration.
+ *
+ * NOT used when looking for a caller check. The convention for stating who may
+ * call a definer function is a `-- caller-check:` MARKER COMMENT, so stripping
+ * comments first destroys the exact evidence being looked for - which it did,
+ * and the fixture's correctly-guarded function was flagged alongside the
+ * unguarded one. Declarations are read from stripped text; guards from raw.
+ */
+function stripComments(sql) {
+    return sql.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+}
+/**
+ * Split into statements on semicolons that are not inside a dollar-quoted body.
+ * A function body is full of semicolons and is one statement; splitting naively
+ * turns every definer function into a dozen fragments and the caller check into
+ * a fragment of its own, which is how a guard goes missing.
+ */
+function statements(sql) {
+    const out = [];
+    let buf = "";
+    let i = 0;
+    let tag = null;
+    while (i < sql.length) {
+        if (!tag) {
+            const m = /^\$([A-Za-z_]*)\$/.exec(sql.slice(i));
+            if (m) {
+                tag = m[0];
+                buf += tag;
+                i += tag.length;
+                continue;
+            }
+            if (sql[i] === ";") {
+                out.push(buf);
+                buf = "";
+                i++;
+                continue;
+            }
+        }
+        else if (sql.startsWith(tag, i)) {
+            buf += tag;
+            i += tag.length;
+            tag = null;
+            continue;
+        }
+        buf += sql[i];
+        i++;
+    }
+    if (buf.trim())
+        out.push(buf);
+    return out;
+}
+const QUALIFIED = /(?:([a-z_][a-z0-9_]*)\.)?([a-z_][a-z0-9_]*)/i;
+function qualify(raw) {
+    const m = QUALIFIED.exec(raw.replace(/"/g, ""));
+    if (!m)
+        return raw;
+    return `${m[1] ?? "public"}.${m[2]}`;
+}
+/**
+ * A definer function states who may call it, one of two ways: a marker comment
+ * naming the predicate, or a runtime check in the body. Either is a statement
+ * somebody can be held to; neither is proof it is correct, and the finding says
+ * "states no caller check", never "is insecure".
+ */
+const CALLER_CHECK = /caller-check|is_account_member|is_platform_staff|auth\.uid\s*\(\s*\)|auth\.role\s*\(\s*\)|current_setting\s*\(|has_role|raise\s+exception|assert\b/i;
+export async function detectDatabase(repo) {
+    // Migrations wherever they live; a `.sql.tmpl` shipped to a customer is the
+    // customer's database, so the template scope rules apply here as everywhere.
+    const files = scopeFor(repo.files, "database");
+    const rlsEnabled = new Set();
+    const rlsForced = new Set();
+    const tablesSeen = new Map();
+    const findings = [];
+    let policies = 0;
+    let definerFunctions = 0;
+    // Two passes: every `alter table` in the repository is collected first,
+    // because a table is very often created in one migration and secured in the
+    // next, and reading them in file order would flag every such table.
+    for (const f of files) {
+        const raw = await repo.read(f);
+        if (!raw)
+            continue;
+        const sql = stripComments(raw);
+        for (const m of sql.matchAll(/alter\s+table\s+(?:if\s+exists\s+)?([a-z0-9_."]+)\s+([a-z\s]*row\s+level\s+security)/gi)) {
+            const t = qualify(m[1]);
+            if (/force/i.test(m[2]))
+                rlsForced.add(t);
+            if (/enable/i.test(m[2]))
+                rlsEnabled.add(t);
+        }
+    }
+    for (const f of files) {
+        const raw = await repo.read(f);
+        if (!raw)
+            continue;
+        const sql = stripComments(raw);
+        for (const m of sql.matchAll(/create\s+table\s+(?:if\s+not\s+exists\s+)?([a-z0-9_."]+)/gi)) {
+            const t = qualify(m[1]);
+            // `create policy p on public.x for select to public` contains the literal
+            // `table` nowhere, but a looser earlier pattern produced a table called
+            // `public.public` from exactly that line. A schema is not a table.
+            if (/^(public|auth|storage|extensions)\.(public|auth|storage)$/.test(t))
+                continue;
+            if (!tablesSeen.has(t))
+                tablesSeen.set(t, f);
+        }
+        // SPLIT THE RAW SQL, STRIP PER STATEMENT.
+        //
+        // The first version split the stripped text and the raw text separately and
+        // paired them by index, which silently drifts: removing comments removes
+        // semicolons inside them, so the two lists stop describing the same
+        // statements. On a real repository that reported 60 definer functions as
+        // stating no caller check when every one of them carried the marker - the
+        // failure mode this whole version exists to remove, arriving in the detector
+        // written to find it.
+        for (const withComments of statements(raw)) {
+            const stmt = stripComments(withComments);
+            if (/create\s+(or\s+replace\s+)?policy/i.test(stmt)) {
+                policies++;
+                const name = /create\s+(?:or\s+replace\s+)?policy\s+("?[a-z0-9_]+"?)/i.exec(stmt)?.[1]?.replace(/"/g, "");
+                // `to anon` hands the policy to unauthenticated callers. `to public`
+                // is the same reach by another name, since anon is a member of public.
+                if (name && /\bto\s+(anon|public)\b/i.test(stmt)) {
+                    findings.push({
+                        kind: "policy_reaches_anon",
+                        subject: name,
+                        file: f,
+                        note: "a policy granted to anon or public is readable by an unauthenticated caller. Deliberate for genuinely public rows, and worth one look per policy.",
+                    });
+                }
+            }
+            if (/create\s+(or\s+replace\s+)?function/i.test(stmt) && /security\s+definer/i.test(stmt)) {
+                definerFunctions++;
+                const name = /create\s+(?:or\s+replace\s+)?function\s+([a-z0-9_."]+)\s*\(/i.exec(stmt)?.[1];
+                if (name && !CALLER_CHECK.test(withComments)) {
+                    findings.push({
+                        kind: "definer_without_check",
+                        subject: qualify(name),
+                        file: f,
+                        note: "runs with the definer's rights and states no caller check. Either it is meant to be callable by anyone, or a grant is the only thing standing between it and one.",
+                    });
+                }
+            }
+        }
+    }
+    for (const [t, f] of tablesSeen) {
+        if (!rlsEnabled.has(t)) {
+            findings.push({
+                kind: "table_without_rls",
+                subject: t,
+                file: f,
+                note: "no `enable row level security` anywhere in the migrations. Right for a lookup table nobody owns; a question for anything carrying one customer's rows.",
+            });
+        }
+        else if (!rlsForced.has(t)) {
+            findings.push({
+                kind: "rls_not_forced",
+                subject: t,
+                file: f,
+                note: "row level security is enabled but not forced, so the table owner bypasses it. Forcing it is one line and closes the gap.",
+            });
+        }
+    }
+    return {
+        files: files.length,
+        tables: tablesSeen.size,
+        policies,
+        definer_functions: definerFunctions,
+        findings: findings.sort((a, b) => a.kind.localeCompare(b.kind) || a.subject.localeCompare(b.subject)).slice(0, 60),
+    };
+}

package/dist/detect/deps 2.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The dependency roster: declared against actually seen.
+ *
+ * The exemplar repo declared 94 runtime dependencies. Nobody could say which
+ * ones worked for a living, because the only ledger was package.json and
+ * package.json records intentions, not usage. This detector reads every
+ * import and require in the repository and every config file that names a
+ * package as a string, and reports the difference.
+ *
+ * Honesty rule: the flag is `no_reference_found`, never "unused". A CLI tool
+ * invoked from an npm script, a peer dependency a plugin loads by name at
+ * runtime - these import nothing and still work. The report says what was
+ * looked for and not found, and lets the founder answer for the rest.
+ *
+ * The ways a package works without an import are looked for too, because each
+ * one was a false flag on a real app before it was: react-dom in a Next app
+ * (a peer of next), tw-animate-css (an `@import` in a stylesheet), @tiptap/pm
+ * (a peer of @tiptap/react), react-email (run as `email` from a script), and
+ * Capacitor plugins (registered by the native build from package.json).
+ */
+import type { Repo } from "../walk.js";
+import type { DepFact } from "./types.js";
+/** `@scope/pkg/deep/path` -> `@scope/pkg`; `pkg/deep` -> `pkg`. Relative and URL imports return null. */
+export declare function packageOf(spec: string): string | null;
+export declare function detectDeps(repo: Repo): Promise<DepFact[]>;