@loucompanion/forge-bridge 0.1.1-dev.242bb53ef13f → 0.1.1-dev.32d4dd5874ee

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/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,39 @@ 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 run = isQa
-                ? await this.providerCli.runQa(dispatch, emit)
-                : await this.providerCli.runImplementation({
-                    dispatch,
-                    worktree,
-                    emit
-                });
+                ? await this.providerCli.runQa(dispatch, emit, signal)
+                : isConflictResolve
+                    ? await this.providerCli.runConflictResolve({
+                        dispatch,
+                        worktree,
+                        emit,
+                        signal
+                    })
+                    : await this.providerCli.runImplementation({
+                        dispatch,
+                        worktree,
+                        emit,
+                        signal
+                    });
+            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 +108,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,17 @@ 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 lane?: string | null;
+    readonly event?: string | null;
 }
 export interface DispatchWorkItem {
     readonly id: string;
@@ -90,6 +101,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 +110,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,49 @@ 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"),
+            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.`);

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.0";
+export declare const forgeBridgeVersion = "0.1.1-dev.32d4dd5874ee";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.0";
+export const forgeBridgeVersion = "0.1.1-dev.32d4dd5874ee";

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,107 @@
+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();
+    if (normalizedPhase === "self_review") {
+        return "self-review-prompt";
+    }
+    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>;