@loucompanion/forge-bridge 0.1.3-dev.2c3feac3af65 → 0.1.3-dev.38afffee8267

package/dist/session/session.types.js

@@ -23,8 +23,10 @@ export function parseRunOnceDispatchPacket(value) {
         qaScope: parseQaScope(packet.qaScope ?? packet.qa_scope),
         qaRework: parseQaRework(packet.qaRework),
         architectRevision: parseArchitectRevision(packet.architectRevision),
+        architectDependencies: parseArchitectDependencies(packet.architectDependencies),
         storyDevelop: parseStoryDevelop(packet.storyDevelop),
         storyQa: parseStoryQa(packet.storyQa),
+        designerRefs: parseDesignerRefs(packet.designerRefs ?? packet.designer_refs),
         draft: parseDraftPrompt(packet.draft)
     };
 }
@@ -282,6 +284,34 @@ function parseArchitectRevision(value) {
         feedback: requiredString(revision, "feedback")
     };
 }
+function parseArchitectDependencies(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const context = asObject(value, "architectDependencies");
+    const prerequisites = context.prerequisites;
+    if (!Array.isArray(prerequisites)) {
+        throw new Error("architectDependencies.prerequisites must be an array.");
+    }
+    return {
+        baseBranch: requiredString(context, "baseBranch").trim(),
+        prerequisites: prerequisites.map((entry, index) => {
+            const prerequisite = asObject(entry, `architectDependencies.prerequisites[${index}]`);
+            return {
+                storyId: requiredString(prerequisite, "storyId").trim(),
+                title: requiredString(prerequisite, "title").trim(),
+                scheduleIndex: optionalNonNegativeInteger(prerequisite, "scheduleIndex"),
+                waveIndex: optionalNonNegativeInteger(prerequisite, "waveIndex"),
+                featureScheduleIndex: optionalNonNegativeInteger(prerequisite, "featureScheduleIndex"),
+                expectedOutput: optionalString(prerequisite, "expectedOutput"),
+                handoffSummary: optionalString(prerequisite, "handoffSummary"),
+                dependencyReason: optionalString(prerequisite, "dependencyReason"),
+                pullRequestNumber: optionalPositiveInteger(prerequisite, "pullRequestNumber"),
+                targetBranch: requiredString(prerequisite, "targetBranch").trim()
+            };
+        })
+    };
+}
 function parseStoryDevelop(value) {
     if (value === undefined || value === null) {
         return null;
@@ -387,6 +417,58 @@ function parseStoryQaDependencies(value) {
         };
     });
 }
+function parseDesignerRefs(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const context = asObject(value, "designerRefs");
+    const refs = context.refs;
+    if (!Array.isArray(refs)) {
+        throw new Error("designerRefs.refs must be an array.");
+    }
+    return {
+        schemaVersion: requiredNumber(context, "schemaVersion"),
+        kind: requiredString(context, "kind"),
+        ownerType: requiredString(context, "ownerType"),
+        ownerId: requiredString(context, "ownerId"),
+        projectId: requiredString(context, "projectId"),
+        repoId: requiredString(context, "repoId"),
+        title: requiredString(context, "title"),
+        refs: refs.map((entry, index) => parseDesignerRefAttachment(entry, index))
+    };
+}
+function parseDesignerRefAttachment(value, index) {
+    const attachment = asObject(value, `designerRefs.refs[${index}]`);
+    return {
+        ref: parseDesignerRef(attachment.ref, index),
+        reason: optionalString(attachment, "reason") ?? "",
+        required: requiredBoolean(attachment, "required"),
+        source: optionalString(attachment, "source") ?? "",
+        lineageKind: optionalString(attachment, "lineageKind") ?? optionalString(attachment, "lineage_kind") ?? "",
+        inheritedFromItemType: optionalString(attachment, "inheritedFromItemType") ?? optionalString(attachment, "inherited_from_item_type"),
+        inheritedFromItemId: optionalString(attachment, "inheritedFromItemId") ?? optionalString(attachment, "inherited_from_item_id"),
+        inheritedFromDesignerRefId: optionalString(attachment, "inheritedFromDesignerRefId") ?? optionalString(attachment, "inherited_from_designer_ref_id"),
+        addedByLane: optionalString(attachment, "addedByLane") ?? optionalString(attachment, "added_by_lane") ?? "",
+        sortOrder: requiredNumber(attachment, "sortOrder"),
+        createdAt: requiredString(attachment, "createdAt")
+    };
+}
+function parseDesignerRef(value, index) {
+    const designerRef = asObject(value, `designerRefs.refs[${index}].ref`);
+    return {
+        id: requiredString(designerRef, "id"),
+        projectId: requiredString(designerRef, "projectId"),
+        repoId: requiredString(designerRef, "repoId"),
+        refKey: requiredString(designerRef, "refKey"),
+        kind: requiredString(designerRef, "kind"),
+        path: requiredString(designerRef, "path"),
+        anchor: optionalString(designerRef, "anchor"),
+        title: optionalString(designerRef, "title") ?? "",
+        contentHash: requiredString(designerRef, "contentHash"),
+        commitSha: requiredString(designerRef, "commitSha"),
+        createdAt: requiredString(designerRef, "createdAt")
+    };
+}
 function parseStringArray(value, label) {
     if (!Array.isArray(value)) {
         throw new Error(`${label} must be an array.`);
@@ -481,6 +563,16 @@ function optionalPositiveInteger(source, key) {
     }
     return value;
 }
+function optionalNonNegativeInteger(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${key} must be a non-negative integer when provided.`);
+    }
+    return value;
+}
 function requiredNumber(source, key) {
     const value = source[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {

package/dist/shared/process/windows-launch.d.ts

@@ -0,0 +1,8 @@
+export interface LaunchCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function buildWindowsCmdLaunch(command: string, args: readonly string[], comSpec?: string | undefined): LaunchCommand;
+export declare function buildWindowsLaunchCommand(commandPath: string, args: readonly string[]): LaunchCommand;
+export declare function windowsCommandLine(command: string, args: readonly string[]): string;
+export declare function quoteWindowsCommandLineArg(value: string): string;

package/dist/shared/process/windows-launch.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+export function buildWindowsCmdLaunch(command, args, comSpec = process.env.ComSpec) {
+    const resolvedComSpec = comSpec?.trim();
+    return {
+        command: resolvedComSpec || "cmd.exe",
+        args: ["/d", "/s", "/v:off", "/c", `"${windowsCommandLine(command, args)}"`]
+    };
+}
+export function buildWindowsLaunchCommand(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if (extension === ".ps1") {
+        return {
+            command: powershellExecutable(),
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", commandPath, ...args]
+        };
+    }
+    if (extension === ".cmd" || extension === ".bat") {
+        return buildWindowsCmdLaunch(commandPath, args);
+    }
+    return { command: commandPath, args };
+}
+export function windowsCommandLine(command, args) {
+    return [command, ...args].map(quoteWindowsCommandLineArg).join(" ");
+}
+export function quoteWindowsCommandLineArg(value) {
+    const escaped = value
+        .replace(/\^/g, "^^")
+        .replace(/%/g, "^%");
+    if (escaped.length > 0 && !/[\s"&|<>()^%!]/.test(escaped)) {
+        return escaped;
+    }
+    return `"${escaped.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+}
+function powershellExecutable() {
+    const systemRoot = process.env.SystemRoot;
+    return systemRoot
+        ? path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+        : "powershell.exe";
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.2c3feac3af65";
+export declare const forgeBridgeVersion = "0.1.3-dev.38afffee8267";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.2c3feac3af65";
+export const forgeBridgeVersion = "0.1.3-dev.38afffee8267";

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

@@ -30,3 +30,14 @@ export declare function createDirectoryLink(sourcePath: string, targetPath: stri
 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>;
+export interface NpmLaunchOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly execPath?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDir?: string;
+    readonly candidates?: readonly string[];
+}
+export declare function resolveNpmLaunch(args: readonly string[], options?: NpmLaunchOptions): {
+    command: string;
+    args: readonly string[];
+};

package/dist/worktree/dependency-warmer.js

@@ -1,6 +1,9 @@
+import { existsSync, realpathSync } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { NodeProcessRunner } from "../shared/process/process.js";
+import { buildWindowsCmdLaunch } from "../shared/process/windows-launch.js";
 import { isSubPath } from "../shared/path/path.js";
 const SKIP_DIR_NAMES = new Set([
     ".git",
@@ -184,7 +187,8 @@ async function runInstallFallback(entry, worktreePath, reason, executor) {
     if (entry.ecosystem === "node") {
         const lockPath = path.join(cwd, "package-lock.json");
         const args = (await pathExists(lockPath)) ? ["ci"] : ["install"];
-        await executor.run(cwd, "npm", args);
+        const launch = resolveNpmLaunch(args);
+        await executor.run(cwd, launch.command, launch.args);
         return { ecosystem: entry.ecosystem, packageRoot: entry.packageRoot, reason, command: `npm ${args.join(" ")}` };
     }
     if (entry.ecosystem === "python") {
@@ -286,6 +290,46 @@ async function sha256File(filePath) {
     const content = await fs.readFile(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
 }
+export function resolveNpmLaunch(args, options = {}) {
+    const env = options.env ?? process.env;
+    const execPath = options.execPath ?? process.execPath;
+    const npmExecPath = env.npm_execpath;
+    if (npmExecPath) {
+        return { command: execPath, args: [npmExecPath, ...args] };
+    }
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        const comSpec = options.env ? env.ComSpec ?? "cmd.exe" : env.ComSpec;
+        return buildWindowsCmdLaunch("npm.cmd", args, comSpec);
+    }
+    for (const candidate of options.candidates ?? defaultNpmCliCandidates(execPath, options.homeDir ?? os.homedir())) {
+        const resolvedCandidate = tryResolveNpmCandidate(candidate);
+        if (resolvedCandidate) {
+            return { command: execPath, args: [resolvedCandidate, ...args] };
+        }
+    }
+    return { command: "npm", args };
+}
+function tryResolveNpmCandidate(candidate) {
+    try {
+        if (!existsSync(candidate)) {
+            return null;
+        }
+        return realpathSync(candidate);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultNpmCliCandidates(execPath, homeDir) {
+    const candidates = [];
+    const execDir = path.dirname(execPath);
+    if (path.isAbsolute(execDir)) {
+        candidates.push(path.join(execDir, "npm"), path.join(execDir, "npm-cli.js"), path.join(execDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    }
+    candidates.push("/usr/bin/npm", "/usr/local/bin/npm", path.join(homeDir, ".npm-global", "bin", "npm"), path.join(homeDir, ".npm-global", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    return candidates;
+}
 const defaultCommandExecutor = {
     async run(cwd, command, args) {
         const result = await defaultProcessRunner.run({ command, cwd, args });

package/dist/worktree/worktree.service.d.ts

@@ -9,7 +9,8 @@ export declare class GitWorktreeService implements WorktreeService {
     private resolveRepoPath;
     private findExistingRepoPath;
     private resolveMatchingRepo;
-    private ensureBaseBranch;
+    private resolveBaseStartPoint;
+    private resetWorktreeToBase;
     private gitRefExists;
     private currentBranch;
     private ensureGitIdentity;

package/dist/worktree/worktree.service.js

@@ -14,7 +14,7 @@ export class GitWorktreeService {
         const baseBranch = normalizeBranchName(request.baseBranch, "develop");
         const repoPath = await this.resolveRepoPath(request.repo, allowedRoot, baseBranch);
         await this.ensureGitIdentity(repoPath);
-        await this.ensureBaseBranch(repoPath, baseBranch);
+        const baseStartPoint = await this.resolveBaseStartPoint(repoPath, baseBranch);
         const shortId = request.workItem.id.replace(/-/g, "").slice(0, 12);
         const kind = safeSegment(request.workItem.kind, "work-item");
         const fallbackWorktreeKey = `${kind}/${shortId}`;
@@ -30,7 +30,7 @@ export class GitWorktreeService {
         const exists = await directoryExists(worktreePath);
         let resolvedWorktreePath;
         if (!exists) {
-            await this.git.run(repoPath, ["worktree", "add", "-B", branchName, worktreePath, baseBranch]);
+            await this.git.run(repoPath, ["worktree", "add", "-B", branchName, worktreePath, baseStartPoint]);
             resolvedWorktreePath = await resolveExistingDirectoryPath(worktreePath);
         }
         else {
@@ -42,6 +42,9 @@ export class GitWorktreeService {
             if (currentBranch !== branchName) {
                 throw new Error(`Existing worktree ${resolvedWorktreePath} is on branch '${currentBranch}', expected '${branchName}'.`);
             }
+            if (shouldResetExistingWorktree(request)) {
+                await this.resetWorktreeToBase(resolvedWorktreePath, baseStartPoint);
+            }
         }
         await this.ensureGitIdentity(resolvedWorktreePath);
         await clearRunArtifactRoots(resolvedWorktreePath, request);
@@ -164,21 +167,27 @@ export class GitWorktreeService {
         const resolved = await resolveExistingDirectoryPath(candidate);
         return isSubPath(allowedRoot, resolved) ? resolved : null;
     }
-    async ensureBaseBranch(repoPath, baseBranch) {
-        if (await this.gitRefExists(repoPath, `refs/heads/${baseBranch}`)) {
-            return;
-        }
+    async resolveBaseStartPoint(repoPath, baseBranch) {
+        const localRef = `refs/heads/${baseBranch}`;
+        const remoteRef = `refs/remotes/origin/${baseBranch}`;
         const origin = await this.git.run(repoPath, ["remote", "get-url", "origin"]).catch(() => "");
-        if (origin.trim().length === 0) {
-            throw new Error(`Base branch '${baseBranch}' was not found in the local checkout.`);
+        if (origin.trim().length > 0) {
+            const fetched = await this.git.run(repoPath, ["fetch", "--prune", "origin"])
+                .then(() => true)
+                .catch(() => false);
+            if (fetched && await this.gitRefExists(repoPath, remoteRef)) {
+                return remoteRef;
+            }
         }
-        await this.git.run(repoPath, ["fetch", "origin", `${baseBranch}:refs/remotes/origin/${baseBranch}`]).catch(() => "");
-        if (await this.gitRefExists(repoPath, `refs/remotes/origin/${baseBranch}`)) {
-            await this.git.run(repoPath, ["branch", baseBranch, `refs/remotes/origin/${baseBranch}`]);
-            return;
+        if (await this.gitRefExists(repoPath, localRef)) {
+            return localRef;
         }
         throw new Error(`Base branch '${baseBranch}' was not found locally or on origin.`);
     }
+    async resetWorktreeToBase(worktreePath, baseStartPoint) {
+        await this.git.run(worktreePath, ["reset", "--hard", baseStartPoint]);
+        await this.git.run(worktreePath, ["clean", "-fd"]);
+    }
     async gitRefExists(repoPath, gitRef) {
         return this.git.run(repoPath, ["show-ref", "--verify", "--quiet", gitRef]).then(() => true).catch(() => false);
     }
@@ -269,6 +278,17 @@ function normalizeOwnerType(value) {
     }
     return null;
 }
+function shouldResetExistingWorktree(request) {
+    const lane = request.lane.trim().toLowerCase();
+    const phase = request.phase.trim().toLowerCase().replace(/-/g, "_");
+    if (lane === "develop" && (phase === "implementation" || phase === "self_review" || phase === "validation")) {
+        return false;
+    }
+    if (lane === "qa" || phase === "qa") {
+        return false;
+    }
+    return true;
+}
 function qaReworkPacketFileName(packetPath) {
     const normalized = packetPath.trim().replace(/\\/g, "/");
     const fileName = normalized.split("/").filter(Boolean).at(-1) ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.3-dev.2c3feac3af65",
+  "version": "0.1.3-dev.38afffee8267",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",