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

package/dist/session/provider-cli/provider-cli.qa-sidecars.js

@@ -0,0 +1,66 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function hasLaunchTarget(target) {
+    return Boolean(target?.url?.trim()
+        || target?.ready_url?.trim()
+        || target?.managed_runtime_port?.trim()
+        || target?.command?.trim()
+        || (target?.routes ?? []).some((route) => route.trim().length > 0));
+}
+export function deterministicBrowserSidecar(workItemId, target, ownerType, ownerId) {
+    const route = primaryLaunchRoute(target);
+    return {
+        relativePath: qaArtifactRelativePath(workItemId, "qa/screenshots/deterministic-browser-check.txt", ownerType, ownerId),
+        content: `Deterministic Forge QA browser evidence\nRoute: ${route}\nConsole errors: []\nNetwork errors: []\nResponsive checks: desktop, mobile\n`
+    };
+}
+export function deterministicBrowserCheck(target, screenshotPath) {
+    const route = primaryLaunchRoute(target);
+    return {
+        route,
+        url: route,
+        status: "pass",
+        summary: "Deterministic browser QA exercised the configured launch target.",
+        actions: ["open launch target", "walk acceptance criteria", "check console/network summaries", "check responsive viewport"],
+        screenshots: [screenshotPath],
+        console_errors: [],
+        network_errors: [],
+        responsive_checks: ["desktop", "mobile"]
+    };
+}
+export function primaryLaunchRoute(target) {
+    return target.ready_url?.trim()
+        || target.url?.trim()
+        || target.routes.find((route) => route.trim().length > 0)?.trim()
+        || target.command?.trim()
+        || "app launch command";
+}
+export async function writeQaSidecarFiles(worktreePath, files) {
+    const sidecars = [];
+    for (const file of files) {
+        const fullPath = path.resolve(worktreePath, file.relativePath);
+        const relativePath = path.relative(worktreePath, fullPath).split(path.sep).join("/");
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error(`QA sidecar path must stay under the worktree: ${file.relativePath}`);
+        }
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, file.content, "utf8");
+        sidecars.push({
+            path: relativePath,
+            content_hash: sha256(file.content),
+            bytes: Buffer.byteLength(file.content, "utf8")
+        });
+    }
+    return sidecars;
+}
+function qaArtifactRelativePath(workItemId, fileName, ownerType, ownerId) {
+    if (ownerType && ownerId) {
+        const ownerDirectory = ownerType.trim().toLowerCase() === "story" ? "stories" : "work-items";
+        return [".forge", ownerDirectory, ownerId, "artifacts", fileName].join("/");
+    }
+    return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}

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

@@ -0,0 +1,9 @@
+import type { RunOnceDispatchPacket } from "../session.types.js";
+import type { ProviderCliRunContext } from "./provider-cli.types.js";
+import type { ProviderOutputState } from "./provider-output-state.js";
+import { type ProviderUsage } from "./provider-usage.js";
+export declare function providerProcessEnv(dispatch: RunOnceDispatchPacket, runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>> | undefined;
+export declare function providerCredentialEnv(dispatch: RunOnceDispatchPacket): Readonly<Record<string, string>>;
+export declare function exactRedactionSecrets(dispatch: RunOnceDispatchPacket): readonly string[];
+export declare function emitProviderUsageEvent(emit: ProviderCliRunContext["emit"], dispatch: RunOnceDispatchPacket, outputState: ProviderOutputState): Promise<void>;
+export declare function estimatedDeterministicUsage(): ProviderUsage;

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

@@ -0,0 +1,41 @@
+import { completionRedactionEnv } from "../phase-completion.js";
+import { addUsage, buildProviderUsageEvent, emptyUsage, hasUsage } from "./provider-usage.js";
+export function providerProcessEnv(dispatch, runtimeEnvironment) {
+    const env = {
+        ...completionRedactionEnv(exactRedactionSecrets(dispatch)),
+        ...providerCredentialEnv(dispatch),
+        ...runtimeEnvironment,
+    };
+    return Object.keys(env).length > 0 ? env : undefined;
+}
+export function providerCredentialEnv(dispatch) {
+    const secret = dispatch.apiKeySecretGrant?.secret;
+    if (!secret || !dispatch.execution.requiresApiKeySecretGrant) {
+        return {};
+    }
+    const provider = dispatch.execution.provider.trim().toLowerCase();
+    if (provider === "codex" || provider === "openai") {
+        return { OPENAI_API_KEY: secret };
+    }
+    return {};
+}
+export function exactRedactionSecrets(dispatch) {
+    const secret = dispatch.apiKeySecretGrant?.secret;
+    if (!secret || !dispatch.execution.requiresApiKeySecretGrant) {
+        return [];
+    }
+    return [secret];
+}
+export async function emitProviderUsageEvent(emit, dispatch, outputState) {
+    const usage = outputState.usage;
+    if (hasUsage(usage)) {
+        await emit(buildProviderUsageEvent(dispatch, usage));
+    }
+}
+export function estimatedDeterministicUsage() {
+    return addUsage(emptyUsage("estimated"), {
+        inputTokens: 1000,
+        outputTokens: 400,
+        source: "estimated"
+    });
+}

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

@@ -1,42 +1,31 @@
 import { GitClient } from "../../shared/git/git.js";
-import { type CompletionToolRuntime } from "../phase-completion.js";
+import type { RunnerDispatchEvent } from "../session.types.js";
 import type { ProviderCliService } from "./provider-cli.base.js";
 import type { ProviderCliDraftContext, ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli.types.js";
-import type { RunOnceDispatchPacket } from "../session.types.js";
-export interface ProviderCliCommand {
-    readonly command: string;
-    readonly args: readonly string[];
+import { type ProviderProcessRunner } from "./provider-cli.process.js";
+export { DeterministicProviderCliService } from "./provider-cli.deterministic.js";
+export { buildProviderCliCommand, codexSandboxModeForPlatform, formatProviderCliCommand, formatProviderCliCommandForCheckpoint } from "./provider-cli.prompts.js";
+export { buildProviderChildEnvironment, chooseWindowsCommandCandidate, resolveCodexNpmDirectLaunch, resolvePackageManagerDirectLaunch, resolveWindowsCommandFromPath, StreamingProviderProcessRunner } from "./provider-cli.process.js";
+export { buildWindowsLaunchCommand } from "../../shared/process/windows-launch.js";
+export type { ProviderCliCommand, ProviderProcessRunner, ProviderProcessRunRequest, ProviderProcessRunResult } from "./provider-cli.process.js";
+export declare class ManagedVerificationProgressEmitter {
+    private readonly logDirectory;
+    private readonly emit;
+    private readonly intervalMs;
+    private timer;
+    private lastSignature;
+    constructor(logDirectory: string | undefined, emit: (event: RunnerDispatchEvent) => Promise<void>, intervalMs?: number);
+    start(): void;
+    stop(): Promise<void>;
+    private scan;
 }
-export interface ProviderProcessRunRequest {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly env?: Readonly<Record<string, string>>;
-}
-export interface ProviderProcessRunResult {
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ProviderProcessRunner {
-    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
-}
-export interface ProviderProcessHandlers {
-    onStdoutLine?(line: string): Promise<void> | void;
-    onStderrLine?(line: string): Promise<void> | void;
-}
-interface ProviderChildEnvironmentOptions {
-    readonly parentEnv?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-    readonly homeDir?: string;
-}
-export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Record<string, string>>, options?: ProviderChildEnvironmentOptions): NodeJS.ProcessEnv;
 export declare class RoutingProviderCliService implements ProviderCliService {
     private readonly realProvider;
     private readonly deterministicProvider;
     constructor(realProvider?: ProviderCliService, deterministicProvider?: ProviderCliService);
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
@@ -44,33 +33,13 @@ export declare class RoutingProviderCliService implements ProviderCliService {
 export declare class ProcessBackedProviderCliService implements ProviderCliService {
     private readonly processRunner;
     private readonly git;
-    constructor(processRunner?: ProviderProcessRunner, git?: GitClient);
+    private readonly providerToolHeartbeatIntervalMs;
+    constructor(processRunner?: ProviderProcessRunner, git?: GitClient, providerToolHeartbeatIntervalMs?: number);
     runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    private runPullRequestRepair;
 }
-export declare class DeterministicProviderCliService implements ProviderCliService {
-    private readonly git;
-    constructor(git?: GitClient);
-    runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
-    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-    runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-    runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-    runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-}
-export declare class StreamingProviderProcessRunner implements ProviderProcessRunner {
-    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
-}
-export declare function chooseWindowsCommandCandidate(candidates: readonly string[]): string | null;
-export declare function buildWindowsLaunchCommand(commandPath: string, args: readonly string[]): ProviderCliCommand;
-export declare function formatProviderCliCommand(command: ProviderCliCommand): string;
-export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket, run?: {
-    readonly prompt?: string;
-    readonly worktreePath?: string;
-    readonly completionTools?: CompletionToolRuntime;
-    readonly skipGitRepoCheck?: boolean;
-}): ProviderCliCommand;
-export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform): "workspace-write" | "danger-full-access";
-export {};