@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.3-dev.fbe15023cdfe

package/dist/session/provider-cli/ci-repair-readiness.d.ts

@@ -0,0 +1,8 @@
+import type { RunOnceDispatchPacket } from "../session.types.js";
+export declare const ciRepairProviderOnlySpecs: readonly ["**/bridge-dispatch.spec.ts", "**/develop-agent-run.spec.ts", "**/runner-availability.spec.ts"];
+export interface CiRepairReadinessResult {
+    readonly path: string;
+    readonly environment: Readonly<Record<string, string>>;
+    readonly manifest: Readonly<Record<string, unknown>>;
+}
+export declare function writeCiRepairReadinessManifest(dispatch: RunOnceDispatchPacket, worktreePath: string, specPath: string, runtimeEnvironment: Readonly<Record<string, string>> | undefined): Promise<CiRepairReadinessResult>;

package/dist/session/provider-cli/ci-repair-readiness.js

@@ -0,0 +1,90 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const ciRepairProviderOnlySpecs = [
+    "**/bridge-dispatch.spec.ts",
+    "**/develop-agent-run.spec.ts",
+    "**/runner-availability.spec.ts",
+];
+export async function writeCiRepairReadinessManifest(dispatch, worktreePath, specPath, runtimeEnvironment) {
+    const metadataRoot = path.dirname(specPath);
+    const manifestPath = path.join(metadataRoot, "ci-repair.readiness.json");
+    const workflowPath = path.join(worktreePath, ".github", "workflows", "ci.yml");
+    const browserReady = runtimeEnvironment?.FORGE_PLAYWRIGHT_BROWSER_READY === "true";
+    const apiUrl = runtimeEnvironment?.FORGE_E2E_API_URL ?? runtimeEnvironment?.FORGE_API_URL ?? null;
+    const webUrl = runtimeEnvironment?.FORGE_E2E_WEB_URL
+        ?? runtimeEnvironment?.FORGE_WEB_URL
+        ?? runtimeEnvironment?.FORGE_PLAYWRIGHT_BASE_URL
+        ?? null;
+    const environment = {
+        ...(runtimeEnvironment ?? {}),
+        ...(apiUrl ? { FORGE_E2E_API_URL: apiUrl } : {}),
+        ...(webUrl ? { FORGE_E2E_WEB_URL: webUrl } : {}),
+        FORGE_CI_REPAIR_READINESS_PATH: manifestPath,
+        FORGE_CI_REPAIR_HANDOFF_PATH: path.join(metadataRoot, "artifacts", "ci-repair.handoff.json"),
+        FORGE_CI_REPAIR_PROVIDER_ONLY_SPECS: JSON.stringify(ciRepairProviderOnlySpecs),
+    };
+    const manifest = {
+        schema_version: 1,
+        generated_by: "forge-bridge",
+        work_item_id: dispatch.workItem.id,
+        session_id: dispatch.session.id,
+        spec: {
+            path: relativePath(worktreePath, specPath),
+            ready: await isFile(specPath),
+        },
+        handoff: {
+            path: relativePath(worktreePath, environment.FORGE_CI_REPAIR_HANDOFF_PATH),
+            completion_tool: "forge.complete_ci_repair",
+            required_before_commit_or_push: true,
+        },
+        pull_request: {
+            provider: dispatch.pullRequest?.provider ?? "unknown",
+            number: dispatch.pullRequest?.number ?? null,
+            url: dispatch.pullRequest?.url ?? null,
+            source_branch: dispatch.pullRequest?.sourceBranch ?? dispatch.cycleRun.baseBranch,
+            target_branch: dispatch.pullRequest?.targetBranch ?? dispatch.cycleRun.requestedBase,
+            check_state: dispatch.pullRequest?.checkState ?? "unknown",
+            required_checks_passed: dispatch.pullRequest?.requiredChecksPassed ?? 0,
+            required_checks_total: dispatch.pullRequest?.requiredChecksTotal ?? 0,
+            failed_job_discovery: "Inspect provider check runs and record exact job/step in the completion payload.",
+        },
+        workflow: {
+            path: relativePath(worktreePath, workflowPath),
+            ready: await isFile(workflowPath),
+            requirement: "Record the failed step and every earlier guard/drift step in workflow_validation.",
+        },
+        runtime: {
+            mode: runtimeEnvironment?.FORGE_RUNTIME_MODE ?? "unknown",
+            application_runtime_ready: Boolean(apiUrl || webUrl),
+            api_url: apiUrl,
+            web_url: webUrl,
+            playwright_config: runtimeEnvironment?.FORGE_PLAYWRIGHT_CONFIG ?? null,
+            playwright_browser_cache: runtimeEnvironment?.PLAYWRIGHT_BROWSERS_PATH ?? null,
+            playwright_browser_ready: browserReady,
+            playwright_browser_install_command: browserReady
+                ? null
+                : runtimeEnvironment?.FORGE_PLAYWRIGHT_BROWSER_INSTALL_COMMAND ?? "npx playwright install chromium",
+        },
+        local_equivalence: {
+            default: "supported",
+            nested_bridge: "provider_only",
+            provider_only_specs: ciRepairProviderOnlySpecs,
+            reason: "A managed Forge attempt cannot safely create a second Bridge/runner control plane inside itself. Provider CI remains authoritative for these specs.",
+            policy: "Do not delete, skip, or weaken provider CI coverage. Record provider_only steps in workflow_validation with this reason.",
+        },
+    };
+    await fs.mkdir(metadataRoot, { recursive: true });
+    await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    return { path: manifestPath, environment, manifest };
+}
+async function isFile(candidate) {
+    try {
+        return (await fs.stat(candidate)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function relativePath(worktreePath, candidate) {
+    return path.relative(worktreePath, candidate).replaceAll(path.sep, "/");
+}

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

@@ -0,0 +1,93 @@
+import { GitClient } from "../../shared/git/git.js";
+import { type CompletionPhase, type CompletionToolRuntime, type DebugCompletionPhase, type QaCompletionGate } from "../phase-completion.js";
+import type { RunOnceDispatchPacket, RunnerDispatchArtifact } from "../session.types.js";
+import type { ProviderCliRunContext } from "./provider-cli.types.js";
+export declare function emitDraftGateArtifacts(emit: ProviderCliRunContext["emit"], worktreePath: string, workItemId: string): Promise<void>;
+export declare function emitDecomposeGateArtifacts(emit: ProviderCliRunContext["emit"], worktreePath: string, workItemId: string): Promise<void>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function summarizeStderr(stderr: string): string;
+export declare function waitForCompletionArtifact(worktreePath: string, workItemId: string, phase: "draft" | "decompose", signal?: AbortSignal): Promise<RunnerDispatchArtifact>;
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function cleanupCompletionTools(completionTools: CompletionToolRuntime, emit: ProviderCliRunContext["emit"]): Promise<void>;
+export declare function commitWorktreeChanges(git: GitClient, worktreePath: string, workItemId: string): Promise<{
+    readonly commitSha: string;
+    readonly changedFiles: readonly string[];
+}>;
+export declare function phaseCompleteEventType(phase: CompletionPhase): string;
+export declare function isDebugCompletionPhaseForProvider(phase: CompletionPhase): phase is DebugCompletionPhase;
+export declare function emitQaArtifactRecorded(emit: ProviderCliRunContext["emit"], worktreePath: string, artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function readQaCompletionArtifactBundle(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<RunnerDispatchArtifact | null>;
+export declare function hasCompleteQaArtifactBundle(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<boolean>;
+export declare function enforceQaBrowserLaunchTargetGate(dispatch: RunOnceDispatchPacket, artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function validateQaBundleSidecarReferences(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<void>;
+export declare function emitQaStructuredEvents(emit: ProviderCliRunContext["emit"], artifact: RunnerDispatchArtifact): Promise<void>;
+interface QaGateArtifactSnapshot {
+    readonly gate: QaCompletionGate;
+    readonly path: string;
+    readonly status: string;
+    readonly producedBy?: string;
+    readonly contentHash?: string;
+}
+export declare function qaArtifactRootForDispatch(worktreePath: string, workItemId: string, dispatch: RunOnceDispatchPacket): string;
+export declare function readQaGateArtifact(artifactRoot: string, gate: QaCompletionGate): Promise<QaGateArtifactSnapshot | null>;
+export declare function nextQaGate(gate: QaCompletionGate): QaCompletionGate | null;
+export declare function emitQaGateAccepted(emit: ProviderCliRunContext["emit"], worktreePath: string, artifact: QaGateArtifactSnapshot, nextGate: QaCompletionGate | null): Promise<void>;
+export declare class LiveQaArtifactEmitter {
+    private readonly worktreePath;
+    private readonly workItemId;
+    private readonly dispatch;
+    private readonly emit;
+    private emittedBundle;
+    private readonly emittedGates;
+    private timer;
+    private pending;
+    constructor(worktreePath: string, workItemId: string, dispatch: RunOnceDispatchPacket, emit: ProviderCliRunContext["emit"]);
+    start(): void;
+    stop(): Promise<void>;
+    hasEmitted(): boolean;
+    private pollQueued;
+    private poll;
+    private emitAvailableGateEvents;
+}
+export declare class LiveArchitectArtifactEmitter {
+    private readonly worktreePath;
+    private readonly workItemId;
+    private readonly emit;
+    private emitted;
+    private timer;
+    private pending;
+    constructor(worktreePath: string, workItemId: string, emit: ProviderCliRunContext["emit"]);
+    start(): void;
+    stop(): Promise<void>;
+    hasEmitted(): boolean;
+    private pollQueued;
+    private poll;
+}
+export declare function hasCompleteArchitectArtifactBundle(worktreePath: string, workItemId: string): Promise<boolean>;
+export declare function emitArchitectStructuredEvents(emit: ProviderCliRunContext["emit"], worktreePath: string, workItemId: string, artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function readJsonObjectFile(filePath: string): Promise<Record<string, unknown>>;
+export declare function arrayField(source: Record<string, unknown>, key: string): Record<string, unknown>[];
+export declare function stringArrayField(source: Record<string, unknown>, key: string): string[];
+export declare function summarizeQaObject(source: Record<string, unknown>): string;
+export declare function qaArtifactRelativePath(workItemId: string, fileName: string, ownerType?: string | null, ownerId?: string | null): string;
+export declare function emitCompletionArtifactRecorded(emit: ProviderCliRunContext["emit"], worktreePath: string, artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function emitPhaseCompletionEvent(emit: ProviderCliRunContext["emit"], artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function emitPhaseGateEvents(emit: ProviderCliRunContext["emit"], artifact: RunnerDispatchArtifact): Promise<void>;
+export declare function completionPhaseFromArtifact(artifact: RunnerDispatchArtifact): CompletionPhase;
+export declare class LiveCompletionArtifactEmitter {
+    private readonly worktreePath;
+    private readonly workItemId;
+    private readonly emit;
+    private readonly phases;
+    private readonly emitted;
+    private timer;
+    private pending;
+    constructor(worktreePath: string, workItemId: string, phase: CompletionPhase, developCycle: boolean, debugCycle: boolean, emit: ProviderCliRunContext["emit"]);
+    start(): void;
+    stop(): Promise<void>;
+    hasEmitted(phase: CompletionPhase): boolean;
+    private pollQueued;
+    private poll;
+}
+export declare function readCompletionArtifactsForRun(worktreePath: string, workItemId: string, phase: CompletionPhase, developCycle: boolean, debugCycle: boolean): Promise<RunnerDispatchArtifact[]>;
+export {};