@loucompanion/forge-bridge 0.1.1-dev.7d43998c4521 → 0.1.1-dev.ac486debe210

package/dist/session/provider-cli/provider-cli.types.d.ts

@@ -3,10 +3,12 @@ import type { WorktreeHandle } from "../../worktree/worktree.types.js";
 export interface ProviderCliRunContext {
     readonly dispatch: RunOnceDispatchPacket;
     readonly worktree: WorktreeHandle;
+    readonly signal?: AbortSignal;
     emit(event: RunnerDispatchEvent): Promise<void>;
 }
 export interface ProviderCliRunResult {
     readonly summary: string;
     readonly spec?: RunnerDispatchSpec | null;
     readonly artifact?: RunnerDispatchArtifact | null;
+    readonly artifacts?: readonly RunnerDispatchArtifact[] | null;
 }

package/dist/session/provider-cli/provider-usage.d.ts

@@ -0,0 +1,25 @@
+import type { RunOnceDispatchPacket, RunnerDispatchEvent } from "../session.types.js";
+export type UsageSource = "provider_reported" | "cli_reported" | "estimated" | "unknown";
+/**
+ * Normalized, provider-agnostic token usage accumulated for a dispatch. Cost is never computed
+ * here; the API recomputes cost from these tokens x model rates (ADR-0006).
+ */
+export interface ProviderUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheCreationTokens: number;
+    readonly reasoningOutputTokens: number;
+    readonly providerDurationMs: number | null;
+    readonly source: UsageSource;
+}
+export declare function emptyUsage(source?: UsageSource): ProviderUsage;
+export declare function addUsage(base: ProviderUsage, next: Partial<ProviderUsage>): ProviderUsage;
+export declare function totalTokens(usage: ProviderUsage): number;
+export declare function hasUsage(usage: ProviderUsage | null): usage is ProviderUsage;
+/**
+ * Builds the durable `provider_usage` event. Token numbers travel as a structured `data` JSON
+ * string (snake_case) that the API parses into a usage_event row.
+ */
+export declare function buildProviderUsageEvent(dispatch: RunOnceDispatchPacket, usage: ProviderUsage): RunnerDispatchEvent;
+export declare function readUsageNumber(source: Record<string, unknown>, key: string): number;

package/dist/session/provider-cli/provider-usage.js

@@ -0,0 +1,64 @@
+export function emptyUsage(source = "unknown") {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        reasoningOutputTokens: 0,
+        providerDurationMs: null,
+        source
+    };
+}
+export function addUsage(base, next) {
+    return {
+        inputTokens: base.inputTokens + nonNegative(next.inputTokens),
+        outputTokens: base.outputTokens + nonNegative(next.outputTokens),
+        cacheReadTokens: base.cacheReadTokens + nonNegative(next.cacheReadTokens),
+        cacheCreationTokens: base.cacheCreationTokens + nonNegative(next.cacheCreationTokens),
+        reasoningOutputTokens: base.reasoningOutputTokens + nonNegative(next.reasoningOutputTokens),
+        providerDurationMs: next.providerDurationMs ?? base.providerDurationMs,
+        source: next.source ?? base.source
+    };
+}
+export function totalTokens(usage) {
+    return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheCreationTokens;
+}
+export function hasUsage(usage) {
+    return usage !== null && totalTokens(usage) > 0;
+}
+/**
+ * Builds the durable `provider_usage` event. Token numbers travel as a structured `data` JSON
+ * string (snake_case) that the API parses into a usage_event row.
+ */
+export function buildProviderUsageEvent(dispatch, usage) {
+    const data = {
+        provider: dispatch.execution.provider,
+        model: dispatch.execution.model,
+        lane: dispatch.execution.lane,
+        phase: dispatch.cycleRun.phase,
+        attempt: dispatch.cycleRun.attempt,
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens,
+        cache_read_tokens: usage.cacheReadTokens,
+        cache_creation_tokens: usage.cacheCreationTokens,
+        reasoning_output_tokens: usage.reasoningOutputTokens,
+        metered: dispatch.execution.authKind === "api_key",
+        usage_source: usage.source,
+        provider_duration_ms: usage.providerDurationMs
+    };
+    const total = totalTokens(usage);
+    return {
+        role: "runner",
+        kind: "checkpoint",
+        content: `Provider usage: ${total} tokens (${usage.inputTokens} in / ${usage.outputTokens} out) for ${dispatch.execution.model}.`,
+        eventType: "provider_usage",
+        data: JSON.stringify(data)
+    };
+}
+export function readUsageNumber(source, key) {
+    const value = source[key];
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function nonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}

package/dist/session/session.service.js

@@ -1,10 +1,10 @@
 import { redactSecrets } from "../shared/redaction/redaction.js";
-import { DeterministicProviderCliService } from "./provider-cli/provider-cli.service.js";
+import { RoutingProviderCliService } from "./provider-cli/provider-cli.service.js";
 import { GitWorktreeService } from "../worktree/worktree.service.js";
 export class BridgeSessionService {
     worktrees;
     providerCli;
-    constructor(worktrees = new GitWorktreeService(), providerCli = new DeterministicProviderCliService()) {
+    constructor(worktrees = new GitWorktreeService(), providerCli = new RoutingProviderCliService()) {
         this.worktrees = worktrees;
         this.providerCli = providerCli;
     }
@@ -30,7 +30,9 @@ export class BridgeSessionService {
             workItem: dispatch.workItem,
             baseBranch: dispatch.cycleRun.baseBranch || dispatch.cycleRun.requestedBase,
             allowedRepoRoot: dispatch.serverLocal.repoRoot,
-            cleanupWorktrees: dispatch.serverLocal.cleanupWorktrees
+            cleanupWorktrees: dispatch.serverLocal.cleanupWorktrees,
+            artifacts: dispatch.artifacts,
+            warmPathOverrides: dispatch.warmPathOverrides
         });
         throwIfAborted(signal);
         await emit({
@@ -39,23 +41,35 @@ export class BridgeSessionService {
             content: `Prepared worktree ${worktree.branchName}.`,
             eventType: "worktree_prepared"
         });
+        if (worktree.dependencyWarm) {
+            await emitDependencyWarmEvents(worktree.dependencyWarm, emit);
+        }
         try {
             throwIfAborted(signal);
-            const isQa = dispatch.execution.role.toLowerCase() === "qa" || dispatch.execution.lane.toLowerCase() === "qa";
+            const lane = dispatch.execution.lane.toLowerCase();
+            const role = dispatch.execution.role.toLowerCase();
+            const isQa = role === "qa" || lane === "qa";
+            const isConflictResolve = role === "conflict_resolve" || lane === "conflict_resolve";
+            const context = {
+                dispatch,
+                worktree,
+                emit,
+                signal
+            };
             const run = isQa
-                ? await this.providerCli.runQa(dispatch, emit)
-                : await this.providerCli.runImplementation({
-                    dispatch,
-                    worktree,
-                    emit
-                });
+                ? await this.providerCli.runQa(context)
+                : isConflictResolve
+                    ? await this.providerCli.runConflictResolve(context)
+                    : await this.providerCli.runImplementation(context);
+            const phaseArtifacts = run.artifacts?.length ? run.artifacts : run.artifact ? [run.artifact] : [];
             return redactSecrets({
                 schemaVersion: 1,
                 exitCode: 0,
                 summary: run.summary,
                 events,
                 spec: run.spec ?? null,
-                artifact: run.artifact ?? null
+                artifact: run.artifact ?? null,
+                artifacts: phaseArtifacts
             }, redactionSecrets);
         }
         finally {
@@ -90,3 +104,29 @@ function validateApiKeySecretGrant(dispatch) {
 function exactSecrets(dispatch) {
     return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
 }
+async function emitDependencyWarmEvents(warm, emit) {
+    if (warm.linked.length > 0) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Warmed dependencies via link: ${warm.linked.join(", ")}.`,
+            eventType: "dependencies_warmed"
+        });
+    }
+    for (const fallback of warm.fallbacks) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Dependency install fallback (${fallback.ecosystem}): ${fallback.reason} Ran \`${fallback.command}\` in ${fallback.packageRoot}.`,
+            eventType: "dependencies_install_fallback"
+        });
+    }
+    if (warm.skipped.length > 0) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Skipped warming missing dependency paths: ${warm.skipped.join(", ")}.`,
+            eventType: "dependencies_warm_skipped"
+        });
+    }
+}

package/dist/session/session.types.d.ts

@@ -9,6 +9,18 @@ export interface RunOnceDispatchPacket {
     readonly execution: DispatchExecution;
     readonly serverLocal: DispatchServerLocalConfig;
     readonly apiKeySecretGrant?: ApiKeySecretGrant | null;
+    readonly artifacts: readonly DispatchResolvedArtifact[];
+    readonly warmPathOverrides?: readonly string[];
+}
+export interface DispatchResolvedArtifact {
+    readonly kind: string;
+    readonly slug: string;
+    readonly scope: string;
+    readonly body: string;
+    readonly contentHash: string;
+    readonly version: number;
+    readonly lane?: string | null;
+    readonly event?: string | null;
 }
 export interface DispatchWorkItem {
     readonly id: string;
@@ -75,6 +87,10 @@ export interface RunnerDispatchEvent {
     readonly kind: string;
     readonly content: string;
     readonly eventType: string;
+    /** Provider/runner-reported event time (ISO-8601) when available, preserved for accurate durations. */
+    readonly occurredAt?: string | null;
+    /** Optional structured telemetry payload (JSON string), e.g. token usage for provider_usage events. */
+    readonly data?: string | null;
 }
 export interface RunnerDispatchSpec {
     readonly repoPath: string;
@@ -90,6 +106,7 @@ export interface RunnerDispatchArtifact {
     readonly report: string;
     readonly producedBy: string;
     readonly status: string;
+    readonly phase?: string | null;
 }
 export interface RunOnceResultPacket {
     readonly schemaVersion: 1;
@@ -98,6 +115,7 @@ export interface RunOnceResultPacket {
     readonly events: readonly RunnerDispatchEvent[];
     readonly spec?: RunnerDispatchSpec | null;
     readonly artifact?: RunnerDispatchArtifact | null;
+    readonly artifacts?: readonly RunnerDispatchArtifact[] | null;
 }
 export interface RunnerEventLine {
     readonly type: "runner_event";

package/dist/session/session.types.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 export function parseRunOnceDispatchPacket(value) {
     const packet = asObject(value, "dispatch packet");
     const schemaVersion = requiredNumber(packet, "schemaVersion");
@@ -14,7 +15,9 @@ export function parseRunOnceDispatchPacket(value) {
         lease: parseLease(packet.lease),
         execution: parseExecution(packet.execution),
         serverLocal: parseServerLocal(packet.serverLocal),
-        apiKeySecretGrant: parseApiKeySecretGrant(packet.apiKeySecretGrant)
+        apiKeySecretGrant: parseApiKeySecretGrant(packet.apiKeySecretGrant),
+        artifacts: parseArtifacts(packet.artifacts),
+        warmPathOverrides: parseWarmPathOverrides(packet.warmPathOverrides)
     };
 }
 export function failureResult(summary, events = []) {
@@ -112,6 +115,50 @@ function parseServerLocal(value) {
         cleanupWorktrees: requiredBoolean(serverLocal, "cleanupWorktrees")
     };
 }
+function parseWarmPathOverrides(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("warmPathOverrides must be an array when provided.");
+    }
+    return value.map((entry, index) => parseWarmPathOverride(entry, index));
+}
+function parseWarmPathOverride(entry, index) {
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+        throw new Error(`warmPathOverrides[${index}] must be a non-empty string.`);
+    }
+    const trimmed = entry.trim();
+    if (path.isAbsolute(trimmed) || path.posix.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed)) {
+        throw new Error(`warmPathOverrides[${index}] must be a relative path.`);
+    }
+    const segments = trimmed.split(/[\\/]+/).filter(Boolean);
+    if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`warmPathOverrides[${index}] must not contain path traversal.`);
+    }
+    return segments.join("/");
+}
+function parseArtifacts(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("artifacts must be an array when provided.");
+    }
+    return value.map((entry, index) => {
+        const artifact = asObject(entry, `artifacts[${index}]`);
+        return {
+            kind: requiredString(artifact, "kind"),
+            slug: requiredString(artifact, "slug"),
+            scope: requiredString(artifact, "scope"),
+            body: optionalString(artifact, "body") ?? "",
+            contentHash: requiredString(artifact, "contentHash"),
+            version: optionalPositiveInteger(artifact, "version") ?? 1,
+            lane: optionalString(artifact, "lane"),
+            event: optionalString(artifact, "event")
+        };
+    });
+}
 function asObject(value, label) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(`${label} must be an object.`);
@@ -142,6 +189,16 @@ function requiredBoolean(source, key) {
     }
     return value;
 }
+function optionalPositiveInteger(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${key} must be a positive integer when provided.`);
+    }
+    return value;
+}
 function requiredNumber(source, key) {
     const value = source[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {

package/dist/shared/cursor-agent/cursor-agent.launch.d.ts

@@ -0,0 +1,9 @@
+export interface CursorAgentLaunch {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function isCursorAgentCommand(command: string): boolean;
+export declare function resolveCursorAgentDirectLaunch(command: string, args: readonly string[]): Promise<CursorAgentLaunch | null>;
+export declare function findLatestCursorAgentVersionDir(versionsRoot: string): Promise<string | null>;
+export declare function compareCursorAgentVersionDirNames(left: string, right: string): number;
+export declare function parseCursorAgentVersionSortKey(name: string): number;

package/dist/shared/cursor-agent/cursor-agent.launch.js

@@ -0,0 +1,66 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const cursorAgentVersionDirPattern = /^\d{4}\.\d{1,2}\.\d{1,2}-.+/;
+export function isCursorAgentCommand(command) {
+    const normalized = command.trim().toLowerCase();
+    return normalized === "cursor-agent" || normalized === "agent";
+}
+export async function resolveCursorAgentDirectLaunch(command, args) {
+    if (!isCursorAgentCommand(command)) {
+        return null;
+    }
+    const localAppData = process.env.LOCALAPPDATA;
+    if (!localAppData) {
+        return null;
+    }
+    const versionDir = await findLatestCursorAgentVersionDir(path.join(localAppData, "cursor-agent", "versions"));
+    if (!versionDir) {
+        return null;
+    }
+    const nodePath = path.join(versionDir, "node.exe");
+    const indexPath = path.join(versionDir, "index.js");
+    if (!(await fileExists(nodePath)) || !(await fileExists(indexPath))) {
+        return null;
+    }
+    return {
+        command: nodePath,
+        args: [indexPath, ...args]
+    };
+}
+export async function findLatestCursorAgentVersionDir(versionsRoot) {
+    let entries;
+    try {
+        entries = await fs.readdir(versionsRoot);
+    }
+    catch {
+        return null;
+    }
+    const latestName = entries
+        .filter((name) => cursorAgentVersionDirPattern.test(name))
+        .sort(compareCursorAgentVersionDirNames)
+        .at(-1);
+    return latestName ? path.join(versionsRoot, latestName) : null;
+}
+export function compareCursorAgentVersionDirNames(left, right) {
+    const leftKey = parseCursorAgentVersionSortKey(left);
+    const rightKey = parseCursorAgentVersionSortKey(right);
+    if (leftKey !== rightKey) {
+        return leftKey - rightKey;
+    }
+    return left.localeCompare(right);
+}
+export function parseCursorAgentVersionSortKey(name) {
+    const datePart = name.split("-")[0] ?? "";
+    const parts = datePart.split(".");
+    if (parts.length !== 3) {
+        return 0;
+    }
+    const year = parts[0] ?? "";
+    const month = (parts[1] ?? "").padStart(2, "0");
+    const day = (parts[2] ?? "").padStart(2, "0");
+    const numeric = Number(`${year}${month}${day}`);
+    return Number.isFinite(numeric) ? numeric : 0;
+}
+async function fileExists(inputPath) {
+    return fs.stat(inputPath).then((stat) => stat.isFile()).catch(() => false);
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.7d43998c4521";
+export declare const forgeBridgeVersion = "0.1.1-dev.ac486debe210";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.7d43998c4521";
+export const forgeBridgeVersion = "0.1.1-dev.ac486debe210";

package/dist/worktree/artifact-injector.d.ts

@@ -0,0 +1,11 @@
+import type { DispatchResolvedArtifact } from "../session/session.types.js";
+export declare function injectWorktreeArtifacts(worktreePath: string, artifacts: readonly DispatchResolvedArtifact[]): Promise<void>;
+export declare function writeArtifact(worktreePath: string, artifact: DispatchResolvedArtifact): Promise<void>;
+export declare function selectLaneCommand(artifacts: readonly DispatchResolvedArtifact[], lane: string, phase: string): DispatchResolvedArtifact | undefined;
+export declare function resolveCommandSlug(lane: string, phase: string): string;
+export declare function buildSpecBody(laneCommand: DispatchResolvedArtifact, workItem: {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly acceptanceCriteria: string;
+}, phase?: string): string;

package/dist/worktree/artifact-injector.js

@@ -0,0 +1,104 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function injectWorktreeArtifacts(worktreePath, artifacts) {
+    for (const artifact of artifacts) {
+        await writeArtifact(worktreePath, artifact);
+    }
+}
+export async function writeArtifact(worktreePath, artifact) {
+    const writtenHash = sha256(artifact.body);
+    if (writtenHash !== artifact.contentHash.toLowerCase()) {
+        throw new Error(`Injected artifact '${artifact.slug}' content_hash mismatch (expected ${artifact.contentHash}, got ${writtenHash}).`);
+    }
+    const kindFolder = kindToFolder(artifact.kind);
+    const scope = safeArtifactSegment("scope", artifact.scope);
+    const slug = safeArtifactSegment("slug", artifact.slug);
+    const forgeRoot = path.resolve(worktreePath, ".forge");
+    const scopeDir = path.resolve(forgeRoot, kindFolder, scope);
+    assertInside(forgeRoot, scopeDir, "Artifact directory");
+    const filePath = normalizedArtifactKind(artifact.kind) === "skill"
+        ? path.resolve(scopeDir, slug, "SKILL.md")
+        : path.resolve(scopeDir, `${slug}.md`);
+    assertInside(forgeRoot, filePath, "Artifact file");
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, artifact.body, "utf8");
+}
+export function selectLaneCommand(artifacts, lane, phase) {
+    const slug = resolveCommandSlug(lane, phase).toLowerCase();
+    return artifacts.find((artifact) => normalizedArtifactKind(artifact.kind) === "command" && artifact.slug.trim().toLowerCase() === slug);
+}
+export function resolveCommandSlug(lane, phase) {
+    const normalizedPhase = phase.trim().toLowerCase().replace(/-/g, "_");
+    if (normalizedPhase === "rework") {
+        return "rework-prompt";
+    }
+    switch (lane.trim().toLowerCase()) {
+        case "architect":
+            return "architect-prompt";
+        case "qa":
+            return "qa-prompt";
+        default:
+            return "dev-prompt";
+    }
+}
+export function buildSpecBody(laneCommand, workItem, phase = "implementation") {
+    const prompt = laneCommand.body.replaceAll("{workItemId}", workItem.id);
+    return `---
+work_item_id: ${workItem.id}
+status: approved
+lane: ${laneCommand.lane ?? "develop"}
+phase: ${phase}
+command_slug: ${laneCommand.slug}
+---
+
+${prompt}
+
+---
+
+# Work item: ${workItem.title}
+
+${workItem.description}
+
+## Acceptance criteria
+
+${workItem.acceptanceCriteria}
+`;
+}
+function kindToFolder(kind) {
+    switch (normalizedArtifactKind(kind)) {
+        case "command":
+            return "commands";
+        case "hook":
+            return "hooks";
+        case "skill":
+            return "skills";
+        default:
+            throw new Error(`Unsupported artifact kind '${kind}'.`);
+    }
+}
+function normalizedArtifactKind(kind) {
+    return kind.trim().toLowerCase();
+}
+function safeArtifactSegment(label, value) {
+    const trimmed = value.trim();
+    if (!trimmed
+        || trimmed === "."
+        || trimmed === ".."
+        || /[\\/]/.test(trimmed)
+        || path.isAbsolute(trimmed)
+        || !/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+        throw new Error(`Artifact ${label} must be a safe path segment.`);
+    }
+    return trimmed;
+}
+function assertInside(root, candidate, label) {
+    const relative = path.relative(root, candidate);
+    if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+        return;
+    }
+    throw new Error(`${label} must stay under ${root}.`);
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}

package/dist/worktree/dependency-warmer.d.ts

@@ -0,0 +1,32 @@
+export type DependencyEcosystem = "node" | "dotnet" | "python";
+export interface WarmPathEntry {
+    readonly relativePath: string;
+    readonly ecosystem: DependencyEcosystem;
+    readonly packageRoot: string;
+}
+export interface WarmDependenciesRequest {
+    readonly baseCheckoutPath: string;
+    readonly worktreePath: string;
+    readonly allowedRoot: string;
+    readonly warmPathOverrides?: readonly string[];
+}
+export interface InstallFallbackResult {
+    readonly ecosystem: DependencyEcosystem;
+    readonly packageRoot: string;
+    readonly reason: string;
+    readonly command: string;
+}
+export interface WarmDependenciesResult {
+    readonly linked: readonly string[];
+    readonly skipped: readonly string[];
+    readonly fallbacks: readonly InstallFallbackResult[];
+}
+export interface CommandExecutor {
+    run(cwd: string, command: string, args: readonly string[]): Promise<void>;
+}
+export declare function detectWarmPaths(repoRoot: string, warmPathOverrides?: readonly string[]): Promise<WarmPathEntry[]>;
+export declare function warmWorktreeDependencies(request: WarmDependenciesRequest, executor?: CommandExecutor): Promise<WarmDependenciesResult>;
+export declare function createDirectoryLink(sourcePath: string, targetPath: string, allowedRoot: string): Promise<void>;
+export declare function lockfilesDiffer(baseCheckoutPath: string, worktreePath: string, packageRootRelative: string): Promise<boolean>;
+export declare function requiresInstallFallback(entry: WarmPathEntry, baseCheckoutPath: string, worktreePath: string, sourceExists: boolean): Promise<string | null>;
+export declare function declaresNativeModules(packageRootPath: string): Promise<boolean>;