@1agents/session-reader 0.1.1

package/dist/src/store/write.d.ts

@@ -0,0 +1,22 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { AgentProvider, NormalizedSession } from '../types.js';
+import type { SessionCandidate } from '../parsers/provider.js';
+/** Store key. `SessionRef.id` stays the provider-native id, untouched. */
+export declare function canonicalId(provider: AgentProvider, nativeId: string): string;
+export interface Fingerprint {
+    sourceSize: number;
+    sourceMtimeMs: number;
+    headHash: string;
+    auxFingerprint?: string;
+}
+/**
+ * Identity of the bytes we parsed. JSONL is append-only in practice, so a
+ * matching head hash rules out the one case size+mtime cannot: a rewrite that
+ * happens to land on the same length.
+ */
+export declare function fingerprintOf(candidate: SessionCandidate, aux?: string): Fingerprint;
+/**
+ * Replaces the L1 rows of one session. Everything derived from it (L2, L3) is
+ * dropped in the same transaction, so the database is never half-new.
+ */
+export declare function writeSession(db: DatabaseSync, session: NormalizedSession, fingerprint: Fingerprint, turnCount: number): string;

package/dist/src/store/write.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { PARSER_VERSION } from './schema.js';
+/** Store key. `SessionRef.id` stays the provider-native id, untouched. */
+export function canonicalId(provider, nativeId) {
+    return `${provider}:${nativeId}`;
+}
+/** Bytes of the file head that go into the fingerprint. */
+const HEAD_BYTES = 64 * 1024;
+/**
+ * Identity of the bytes we parsed. JSONL is append-only in practice, so a
+ * matching head hash rules out the one case size+mtime cannot: a rewrite that
+ * happens to land on the same length.
+ */
+export function fingerprintOf(candidate, aux) {
+    let headHash = '';
+    try {
+        const fd = fs.openSync(candidate.path, 'r');
+        try {
+            const buffer = Buffer.alloc(Math.min(HEAD_BYTES, candidate.sizeBytes || HEAD_BYTES));
+            const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+            headHash = crypto.createHash('sha256').update(buffer.subarray(0, read)).digest('hex');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        /* unreadable head — size+mtime still gate re-indexing */
+    }
+    return {
+        sourceSize: candidate.sizeBytes,
+        sourceMtimeMs: Math.round(candidate.mtimeMs),
+        headHash,
+        ...(aux ? { auxFingerprint: aux } : {}),
+    };
+}
+/**
+ * Replaces the L1 rows of one session. Everything derived from it (L2, L3) is
+ * dropped in the same transaction, so the database is never half-new.
+ */
+export function writeSession(db, session, fingerprint, turnCount) {
+    const id = canonicalId(session.ref.provider, session.ref.id);
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        for (const table of ['events', 'file_ops', 'commands', 'jobs']) {
+            db.prepare(`DELETE FROM ${table} WHERE session_id = ?`).run(id);
+        }
+        db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+        db.prepare(`INSERT INTO sessions (
+         id, provider, native_id, source_path, workspace, title, started_at, ended_at,
+         event_count, turn_count, source_size, source_mtime_ms, head_hash, aux_fingerprint,
+         parser_version, extractor_version, edge_version, indexed_at, artifacts_json, stats_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, ?)`).run(id, session.ref.provider, session.ref.id, session.ref.path, session.ref.workspace ?? null, session.ref.title ?? null, session.ref.createdAt ?? null, session.ref.updatedAt ?? null, session.turns.length, turnCount, fingerprint.sourceSize, fingerprint.sourceMtimeMs, fingerprint.headHash, fingerprint.auxFingerprint ?? null, PARSER_VERSION, new Date().toISOString(), JSON.stringify(session.artifacts), JSON.stringify(session.stats));
+        const insert = db.prepare(`INSERT INTO events (
+         session_id, idx, kind, text, tool_name, tool_args_json, tool_result, is_error,
+         ts, source_index, exit_code, pid, duration_ms, provider_truncated
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        // Event text is stored whole. Capping it at 128KB shrank the index by
+        // 0.08% and silently dropped search hits from long build logs — exactly
+        // the kind of "looks complete, isn't" answer this store exists to remove.
+        for (const event of session.turns) {
+            insert.run(id, event.index, event.kind, event.text ?? null, event.toolName ?? null, event.toolArgs ? JSON.stringify(event.toolArgs) : null, event.toolResult ?? null, event.isError === undefined ? null : event.isError ? 1 : 0, event.timestamp ?? null, event.sourceIndex ?? null, event.exitCode ?? null, event.processId ?? null, event.durationMs ?? null, event.truncated === undefined ? null : event.truncated ? 1 : 0);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+    return id;
+}

package/dist/src/turns.d.ts

@@ -0,0 +1,14 @@
+import type { NormalizedSession, TurnDetail, TurnEvent, TurnSummary } from './types.js';
+export declare function summarizeTurns(session: NormalizedSession): TurnSummary[];
+export declare function turnDetail(session: NormalizedSession, turnNo: number): TurnDetail;
+export interface EventDetail extends TurnEvent {
+    /** Full text, recovered from the provider's side files when truncated. */
+    fullText?: string;
+    /** Set when the transcript is short and the full copy could not be found. */
+    truncationNote?: string;
+}
+/**
+ * Tier three: one event with its untruncated payload. Antigravity shortens long
+ * step output in the transcript and keeps the full copy under `steps/<n>/`.
+ */
+export declare function eventDetail(session: NormalizedSession, eventIndex: number): Promise<EventDetail>;

package/dist/src/turns.js

@@ -0,0 +1,156 @@
+import { readFullStepOutput } from './parsers/antigravity.js';
+import { oneLine } from './util/text.js';
+import { fileWrites, rawCommand, resolveWritePath } from './writes.js';
+import { classifyUserTurn } from './classify.js';
+/**
+ * Whether a turn wrapped up — never a claim about what it achieved.
+ * Every non-`completed` verdict must name the signal that produced it.
+ */
+function assessTurn(events, native, nextPrompt, nudgeCount) {
+    const evidence = [];
+    let status = 'completed';
+    const assistantTail = [...events].reverse().find((event) => event.kind === 'assistant' && event.text?.trim());
+    const nonUser = events.filter((event) => event.kind !== 'user');
+    const openCalls = events.filter((event) => event.kind === 'tool_call' &&
+        !events.some((other) => other.kind === 'tool_result' && other.index > event.index));
+    const last = events.at(-1);
+    if (!nonUser.length) {
+        status = 'no_response';
+        evidence.push('该轮除用户消息外没有任何助理事件');
+    }
+    if (native && !native.completed) {
+        status = 'unfinished';
+        evidence.push(`provider 记录了 task_started 但没有配对的 task_complete${native.id ? `（turn ${native.id.slice(0, 13)}）` : ''}`);
+    }
+    if (openCalls.length) {
+        if (status === 'completed')
+            status = 'interrupted';
+        evidence.push(`事件 #${openCalls[0].index} 的工具调用没有对应结果`);
+    }
+    if (last?.kind === 'tool_result' && (last.exitCode ?? 0) !== 0 && !assistantTail) {
+        if (status === 'completed')
+            status = 'failed_tail';
+        evidence.push(`以 exit ${last.exitCode} 的结果收尾，其后没有助理回复`);
+    }
+    if (nudgeCount > 0) {
+        if (status === 'completed')
+            status = 'nudged';
+        evidence.push(`下一轮是纯推进指令${nudgeCount > 1 ? `，连续 ${nudgeCount} 次` : ''}（"${nextPrompt?.text?.trim().slice(0, 20) ?? ''}"）`);
+    }
+    return { status, evidence };
+}
+/**
+ * Turn boundaries: codex records them natively, the others start a new turn on
+ * every user message.
+ */
+function boundaries(session) {
+    const starts = session.turns
+        .filter((turn) => turn.kind === 'user' && turn.text?.trim())
+        .map((turn) => turn.index);
+    if (!starts.length && session.turns.length)
+        return [0];
+    // Anything before the first user message belongs to turn 1.
+    if (starts[0] !== 0 && session.turns.length)
+        starts[0] = 0;
+    return starts;
+}
+/**
+ * Providers fire `task_started` a few seconds *before* the first event of the
+ * turn it opens, so a boundary belongs to the next turn that starts, not to
+ * the turn whose window happens to contain it.
+ */
+function boundariesByTurn(declared, turnStarts) {
+    const byTurn = new Map();
+    for (const boundary of declared) {
+        if (!boundary.startedAt)
+            continue;
+        const at = Date.parse(boundary.startedAt);
+        let owner = turnStarts.findIndex((start) => start !== undefined && Date.parse(start) >= at);
+        if (owner === -1)
+            owner = turnStarts.length - 1;
+        const list = byTurn.get(owner) ?? [];
+        list.push(boundary);
+        byTurn.set(owner, list);
+    }
+    return byTurn;
+}
+export function summarizeTurns(session) {
+    const starts = boundaries(session);
+    const workspace = session.ref.workspace;
+    const declared = session.stats.turnBoundaries;
+    const nativeByTurn = boundariesByTurn(declared, starts.map((start) => session.turns[start]?.timestamp));
+    return starts.map((start, i) => {
+        const end = (starts[i + 1] ?? session.turns.length) - 1;
+        const events = session.turns.slice(start, end + 1);
+        const files = new Set();
+        let commands = 0;
+        let errors = 0;
+        for (const event of events) {
+            for (const write of fileWrites(event))
+                files.add(resolveWritePath(write, workspace));
+            if (rawCommand(event))
+                commands++;
+            if (event.kind === 'tool_result' && event.isError)
+                errors++;
+        }
+        const prompt = events.find((event) => event.kind === 'user' && event.text?.trim());
+        // Count the run of pure "keep going" messages that follows this turn.
+        let nudgeCount = 0;
+        for (let k = i + 1; k < starts.length; k++) {
+            const next = session.turns[starts[k]];
+            if (next?.kind === 'user' && next.text && classifyUserTurn(next.text) === 'nudge')
+                nudgeCount++;
+            else
+                break;
+        }
+        const nextPrompt = session.turns[starts[i + 1] ?? -1];
+        const outcome = [...events].reverse().find((event) => event.kind === 'assistant' && event.text?.trim());
+        const startedAt = events[0]?.timestamp;
+        const endedAt = events.at(-1)?.timestamp;
+        const owned = nativeByTurn.get(i) ?? [];
+        // A turn is only as finished as its least finished declared boundary.
+        const native = owned.find((boundary) => !boundary.completed) ?? owned[0];
+        const durationMs = (owned.length === 1 ? native?.durationMs : undefined) ??
+            (startedAt && endedAt ? Math.max(0, Date.parse(endedAt) - Date.parse(startedAt)) || undefined : undefined);
+        const { status, evidence } = assessTurn(events, native, nextPrompt, nudgeCount);
+        return {
+            no: i + 1,
+            status,
+            evidence,
+            nudgeCount,
+            startedAt,
+            endedAt,
+            ...(durationMs ? { durationMs } : {}),
+            prompt: oneLine(prompt?.text, 120) || '（无用户消息）',
+            events: [start, end],
+            eventCount: events.length,
+            files: [...files],
+            commands,
+            errors,
+            outcome: oneLine(outcome?.text ?? native?.lastMessage, 120),
+        };
+    });
+}
+export function turnDetail(session, turnNo) {
+    const summaries = summarizeTurns(session);
+    const summary = summaries[turnNo - 1];
+    if (!summary)
+        throw new Error(`no turn ${turnNo} (session has ${summaries.length})`);
+    return { summary, events: session.turns.slice(summary.events[0], summary.events[1] + 1) };
+}
+/**
+ * Tier three: one event with its untruncated payload. Antigravity shortens long
+ * step output in the transcript and keeps the full copy under `steps/<n>/`.
+ */
+export async function eventDetail(session, eventIndex) {
+    const event = session.turns[eventIndex];
+    if (!event)
+        throw new Error(`no event ${eventIndex} (session has ${session.turns.length})`);
+    if (!event.truncated || session.ref.provider !== 'antigravity' || event.sourceIndex === undefined) {
+        return { ...event };
+    }
+    const full = await readFullStepOutput(session.ref.path, event.sourceIndex);
+    return full
+        ? { ...event, fullText: full }
+        : { ...event, truncationNote: `transcript 已截断，steps/${event.sourceIndex}/output.txt 不存在` };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,294 @@
+/** Canonical domain types shared by every provider parser. */
+export type AgentProvider = 'antigravity' | 'claude' | 'codex' | 'cursor' | 'unknown';
+/** Cheap metadata about a discovered session, obtained without a full parse. */
+export interface SessionRef {
+    id: string;
+    provider: AgentProvider;
+    /** Native file that holds the transcript. */
+    path: string;
+    title?: string;
+    /** Canonical absolute working directory the session ran in. */
+    workspace?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    sizeBytes?: number;
+}
+export type TurnKind = 'user' | 'assistant' | 'thinking' | 'tool_call' | 'tool_result';
+export interface TurnEvent {
+    id: string;
+    index: number;
+    kind: TurnKind;
+    text?: string;
+    toolName?: string;
+    toolArgs?: Record<string, unknown>;
+    toolResult?: string;
+    isError?: boolean;
+    timestamp?: string;
+    /** Provider-native index of the record this event came from. */
+    sourceIndex?: number;
+    /** The provider stored a shortened copy; the full text lives elsewhere. */
+    truncated?: boolean;
+    /** OS process id, when the provider records one for a command. */
+    processId?: string;
+    /** Shell exit status, when the provider records or prints one. */
+    exitCode?: number;
+    durationMs?: number;
+}
+/** A file the agent produced alongside the session (plans, reports, images). */
+export interface SessionArtifact {
+    name: string;
+    path: string;
+    kind: 'markdown' | 'image' | 'other';
+    /** Only read for text artifacts. */
+    content?: string;
+    /** The agent's own one-line description, when it recorded one. */
+    summary?: string;
+    sizeBytes?: number;
+    updatedAt?: string;
+}
+/**
+ * How much a fact is worth trusting.
+ * - `observed`  — the provider recorded it as a structured field of its own.
+ * - `derived`   — a deterministic rule over an action that provably ran.
+ * - `candidate` — merely mentioned in text; nobody was seen acting on it.
+ */
+export type Provenance = 'observed' | 'derived' | 'candidate';
+/** Answers "why do you believe this?" for a single extracted fact. */
+export interface FactSource {
+    provenance: Provenance;
+    /** The rule that produced it, e.g. `tool:Write`, `shell:redirect`. */
+    extractor: string;
+    /** Event index it was extracted from. */
+    event?: number;
+    turn?: number;
+}
+export interface FileChange {
+    path: string;
+    change: 'add' | 'update' | 'delete';
+    sizeBytes?: number;
+}
+export interface BackgroundTask {
+    id: string;
+    title?: string;
+    log?: string;
+    /** Only trustworthy when the provider records completion notices. */
+    finished: boolean;
+}
+export interface TokenUsage {
+    input: number;
+    output: number;
+    total: number;
+    /** Prefix replays served from cache — reported separately, never as input. */
+    cacheRead?: number;
+}
+export interface TurnBoundary {
+    /** Provider turn id — boundaries must be paired by id, never by position. */
+    id?: string;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    lastMessage?: string;
+    /** A start with no matching completion means the turn never wrapped up. */
+    completed: boolean;
+}
+/** One shell command with whatever the provider actually recorded about it. */
+export interface CommandRecord {
+    eventIndex: number;
+    turn: number;
+    command: string;
+    host?: string;
+    cwd?: string;
+    exitCode?: number;
+    durationMs?: number;
+    pid?: string;
+    stderr?: string;
+    timestamp?: string;
+    provenance: Provenance;
+    extractor: string;
+    /** Errors only: a later command with the same prefix exited zero. */
+    laterSucceeded?: boolean;
+}
+export type JobStatus = 'completed' | 'failed' | 'running' | 'unknown';
+export interface AsyncJob {
+    id: string;
+    command?: string;
+    pid?: string;
+    host?: string;
+    log?: string;
+    startedAt?: string;
+    discoveredFrom?: number;
+    provenance: Provenance;
+    extractor: string;
+    status: JobStatus;
+    /** Why we claim that status. Never empty for anything but `unknown`. */
+    evidence: string[];
+}
+export type FileGroup = 'project' | 'runtime' | 'log';
+export interface FileRecord {
+    path: string;
+    host?: string;
+    operation: string;
+    turn: number;
+    eventIndex: number;
+    timestamp?: string;
+    provenance: Provenance;
+    extractor: string;
+    group: FileGroup;
+}
+/** Structured facts a provider records natively — never inferred by us. */
+export interface ProviderStats {
+    tokens?: TokenUsage;
+    models: string[];
+    branches: string[];
+    /** Authoritative file changes, when the provider tracks them itself. */
+    fileChanges: FileChange[];
+    commandExecutions?: number;
+    uploads: {
+        name: string;
+        path: string;
+        sizeBytes?: number;
+    }[];
+    backgroundTasks: BackgroundTask[];
+    /** Provider-declared turn boundaries (codex task_started/task_complete). */
+    turnBoundaries: TurnBoundary[];
+    /** Command ledger, when the provider records commands itself. */
+    commands: CommandRecord[];
+    /** Counts of anything else worth surfacing: images viewed, compactions… */
+    extras: Record<string, number>;
+}
+export declare function emptyProviderStats(): ProviderStats;
+export interface NormalizedSession {
+    ref: SessionRef;
+    turns: TurnEvent[];
+    artifacts: SessionArtifact[];
+    stats: ProviderStats;
+}
+export type DigestFocus = 'marketing' | 'review' | 'full';
+export interface TurningPoint {
+    timestamp?: string;
+    kind: 'request' | 'redirect' | 'failure' | 'outcome';
+    text: string;
+}
+export interface SessionDigest {
+    session: SessionRef;
+    goal: string;
+    touchedFiles: string[];
+    commands: string[];
+    turningPoints: TurningPoint[];
+    artifacts: SessionArtifact[];
+    markdown: string;
+}
+export interface UnifiedTimelineEntry {
+    timestamp?: string;
+    provider: AgentProvider;
+    sessionId: string;
+    kind: TurnKind;
+    summary: string;
+}
+export interface FileTouch {
+    provider: AgentProvider;
+    sessionId: string;
+    timestamp?: string;
+    toolName?: string;
+    provenance?: Provenance;
+    /** Remote host, when the file was written over ssh/scp. */
+    host?: string;
+}
+export interface WorkspaceDigest {
+    workspace: string;
+    sessions: SessionRef[];
+    collaboratingAgents: AgentProvider[];
+    unifiedTimeline: UnifiedTimelineEntry[];
+    fileAttribution: Record<string, FileTouch[]>;
+    markdown: string;
+}
+export interface GitCommit {
+    sha?: string;
+    message: string;
+    timestamp?: string;
+}
+/** Session-level counters — the top tier of the three-level view. */
+export interface SessionStats {
+    turns: number;
+    events: Record<TurnKind, number>;
+    /** Distinct files touched — always equals the file ledger's row count. */
+    filesChanged: number;
+    /** Write actions observed — a file written three times counts three. */
+    fileChangeEvents: number;
+    /** How the ledger's rows break down — a single label would misdescribe a mix. */
+    filesByProvenance: Record<Provenance, number>;
+    commands: number;
+    errors: number;
+    commits: GitCommit[];
+    branches: string[];
+    models: string[];
+    tokens?: TokenUsage;
+    artifacts: SessionArtifact[];
+    uploads: {
+        name: string;
+        path: string;
+        sizeBytes?: number;
+    }[];
+    jobs: AsyncJob[];
+    jobCounts: Record<JobStatus, number>;
+    extras: Record<string, number>;
+}
+export type UserTurnKind = 'correction' | 'nudge' | 'paste';
+export interface UserTurnNote {
+    timestamp?: string;
+    kind: UserTurnKind;
+    text: string;
+}
+export interface SessionOverview {
+    session: SessionRef;
+    stats: SessionStats;
+    goal: string;
+    corrections: UserTurnNote[];
+    nudges: number;
+    pastes: number;
+    anchors: {
+        hosts: string[];
+        /**
+         * Paths merely mentioned in text — always `candidate`, never proof that
+         * anything acted on them. `firstTurn`/`lastTurn` express recency only.
+         */
+        paths: {
+            path: string;
+            hits: number;
+            kind: 'dir' | 'file';
+            firstTurn: number;
+            lastTurn: number;
+            provenance: Provenance;
+        }[];
+    };
+    /** The file ledger itself — the same rows `1session files` prints. */
+    writes: FileRecord[];
+    pitfalls: string[];
+    lastWord: string;
+    markdown: string;
+}
+export type TurnStatus = 'completed' | 'unfinished' | 'nudged' | 'interrupted' | 'no_response' | 'failed_tail';
+export interface TurnSummary {
+    no: number;
+    /** Whether the turn wrapped up — never a claim about what it achieved. */
+    status: TurnStatus;
+    /** Every signal that fired. Empty only when the status is `completed`. */
+    evidence: string[];
+    /** How many pure "keep going" messages followed this turn. */
+    nudgeCount: number;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    prompt: string;
+    /** Inclusive event index range this turn spans. */
+    events: [number, number];
+    eventCount: number;
+    files: string[];
+    commands: number;
+    errors: number;
+    outcome: string;
+}
+export interface TurnDetail {
+    summary: TurnSummary;
+    events: TurnEvent[];
+}

package/dist/src/types.js

@@ -0,0 +1,13 @@
+/** Canonical domain types shared by every provider parser. */
+export function emptyProviderStats() {
+    return {
+        models: [],
+        branches: [],
+        fileChanges: [],
+        uploads: [],
+        backgroundTasks: [],
+        turnBoundaries: [],
+        commands: [],
+        extras: {},
+    };
+}

package/dist/src/util/jsonl.d.ts

@@ -0,0 +1,6 @@
+export interface JsonlOptions {
+    /** Stop after this many parsed objects. */
+    maxLines?: number;
+}
+/** Streams a `.jsonl` file, silently skipping blank or malformed lines. */
+export declare function readJsonl(file: string, options?: JsonlOptions): AsyncGenerator<Record<string, unknown>>;

package/dist/src/util/jsonl.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import readline from 'node:readline';
+/** Streams a `.jsonl` file, silently skipping blank or malformed lines. */
+export async function* readJsonl(file, options = {}) {
+    const stream = fs.createReadStream(file, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let emitted = 0;
+    try {
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== 'object')
+                continue;
+            yield parsed;
+            emitted++;
+            if (options.maxLines && emitted >= options.maxLines)
+                return;
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+}

package/dist/src/util/paths.d.ts

@@ -0,0 +1,15 @@
+export declare function expandHome(p: string): string;
+/**
+ * Normalizes anything a session file may contain into one comparable absolute
+ * path: `~`, relative paths, `file://` URIs, percent-encoding and symlinks.
+ */
+export declare function canonicalizePath(input: string): string;
+/** True when `child` is `parent` itself or lives under it. */
+export declare function isInside(parent: string, child: string): boolean;
+/**
+ * Claude Code names its project directories by replacing every non-alphanumeric
+ * character of the cwd with `-` (lossy, so we only ever slugify forwards).
+ */
+export declare function slugifyWorkspace(p: string): string;
+/** Walks up from a file to the closest directory holding `.git`. */
+export declare function findRepoRoot(from: string): string | undefined;