@loucompanion/forge-bridge 0.1.1-dev.242bb53ef13f → 0.1.1-dev.2ac58b6f94ce

package/dist/worktree/worktree.service.js

@@ -2,6 +2,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { GitClient } from "../shared/git/git.js";
 import { ensureDirectory, isSubPath, resolveExistingDirectoryPath, safeSegment } from "../shared/path/path.js";
+import { injectWorktreeArtifacts } from "./artifact-injector.js";
+import { warmWorktreeDependencies } from "./dependency-warmer.js";
 export class GitWorktreeService {
     git;
     constructor(git = new GitClient()) {
@@ -9,13 +11,14 @@ export class GitWorktreeService {
     }
     async prepare(request) {
         const allowedRoot = await ensureDirectory(request.allowedRepoRoot);
-        const repoPath = await this.resolveRepoPath(request.repo, allowedRoot);
         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 shortId = request.workItem.id.replace(/-/g, "").slice(0, 12);
         const kind = safeSegment(request.workItem.kind, "work-item");
         const branchName = normalizeBranchName(`${kind}/${shortId}`, "work-item/unknown");
-        const worktreeRoot = path.join(path.dirname(repoPath), ".forge-worktrees", path.basename(repoPath));
+        const worktreeRoot = resolveWorktreeRoot(allowedRoot, repoPath);
         const worktreePath = path.join(worktreeRoot, kind, shortId);
         const resolvedWorktreeParent = await ensureDirectory(path.dirname(worktreePath));
         if (!isSubPath(allowedRoot, resolvedWorktreeParent)) {
@@ -34,12 +37,22 @@ export class GitWorktreeService {
             }
         }
         await this.ensureGitIdentity(resolvedWorktreePath);
+        if (request.artifacts.length > 0) {
+            await injectWorktreeArtifacts(resolvedWorktreePath, request.artifacts);
+        }
+        const dependencyWarm = await warmWorktreeDependencies({
+            baseCheckoutPath: repoPath,
+            worktreePath: resolvedWorktreePath,
+            allowedRoot,
+            warmPathOverrides: request.warmPathOverrides
+        });
         return {
             repoPath,
             worktreePath: resolvedWorktreePath,
             branchName,
             baseBranch,
-            cleanupWorktrees: request.cleanupWorktrees
+            cleanupWorktrees: request.cleanupWorktrees,
+            dependencyWarm
         };
     }
     async release(handle) {
@@ -54,7 +67,7 @@ export class GitWorktreeService {
             await fs.rm(handle.worktreePath, { recursive: true, force: true });
         }
     }
-    async resolveRepoPath(repo, allowedRoot) {
+    async resolveRepoPath(repo, allowedRoot, baseBranch) {
         if (repo.serverLocalPath && repo.serverLocalPath.trim().length > 0) {
             const requestedPath = await resolveExistingDirectoryPath(repo.serverLocalPath);
             if (!isSubPath(allowedRoot, requestedPath) || !(await gitMetadataExists(requestedPath, allowedRoot))) {
@@ -65,14 +78,34 @@ export class GitWorktreeService {
         if (!repo.cloneOnDemand) {
             throw new Error("Repo has no server-local path and cloneOnDemand is disabled.");
         }
-        const repoPath = path.join(allowedRoot, `${safeSegment(repo.name, "repo")}-${repo.id.replace(/-/g, "")}`);
+        const discovered = await this.findExistingRepoPath(repo, allowedRoot);
+        if (discovered) {
+            return discovered;
+        }
+        const repoPath = path.join(managedRepoRoot(allowedRoot), `${safeSegment(repo.name, "repo")}-${repo.id.replace(/-/g, "")}`);
         if (!(await gitMetadataExists(repoPath, allowedRoot))) {
-            await fs.mkdir(repoPath, { recursive: true });
-            await this.git.run(repoPath, ["init", "-b", normalizeBranchName(repo.defaultBranch, "develop")]);
-            await this.ensureGitIdentity(repoPath);
-            await fs.writeFile(path.join(repoPath, "README.md"), `# ${repo.name}\n`, "utf8");
-            await this.git.run(repoPath, ["add", "README.md"]);
-            await this.git.run(repoPath, ["commit", "-m", "seed forge bridge repo"]);
+            const repoPathExists = await pathExists(repoPath);
+            if (repoPathExists) {
+                throw new Error(`Repository path ${repoPath} exists but is not a git checkout.`);
+            }
+            if (isCloneableRemote(repo.remoteUrl)) {
+                await fs.mkdir(path.dirname(repoPath), { recursive: true });
+                try {
+                    await this.git.run(path.dirname(repoPath), ["clone", "--origin", "origin", repo.remoteUrl.trim(), repoPath]);
+                }
+                catch (err) {
+                    await fs.rm(repoPath, { recursive: true, force: true });
+                    throw err;
+                }
+            }
+            else {
+                await fs.mkdir(repoPath, { recursive: true });
+                await this.git.run(repoPath, ["init", "-b", baseBranch]);
+                await this.ensureGitIdentity(repoPath);
+                await fs.writeFile(path.join(repoPath, "README.md"), `# ${repo.name}\n`, "utf8");
+                await this.git.run(repoPath, ["add", "README.md"]);
+                await this.git.run(repoPath, ["commit", "-m", "seed forge bridge repo"]);
+            }
         }
         const resolved = await resolveExistingDirectoryPath(repoPath);
         if (!isSubPath(allowedRoot, resolved)) {
@@ -80,11 +113,85 @@ export class GitWorktreeService {
         }
         return resolved;
     }
+    async findExistingRepoPath(repo, allowedRoot) {
+        const expectedRemote = normalizeRemote(repo.remoteUrl);
+        const rawName = repo.name.trim();
+        const nameCandidates = uniqueStrings([
+            isSinglePathSegment(rawName) ? path.join(allowedRoot, rawName) : "",
+            path.join(allowedRoot, safeSegment(repo.name, "repo"))
+        ]);
+        for (const candidate of nameCandidates) {
+            const resolved = await this.resolveMatchingRepo(candidate, allowedRoot, expectedRemote);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        if (expectedRemote.length > 0) {
+            const entries = await fs.readdir(allowedRoot, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name === ".forge-worktrees") {
+                    continue;
+                }
+                const resolved = await this.resolveMatchingRepo(path.join(allowedRoot, entry.name), allowedRoot, expectedRemote);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        return null;
+    }
+    async resolveMatchingRepo(candidate, allowedRoot, expectedRemote) {
+        if (!(await gitMetadataExists(candidate, allowedRoot))) {
+            return null;
+        }
+        if (expectedRemote.length > 0) {
+            const origin = await this.git.run(candidate, ["remote", "get-url", "origin"]).catch(() => "");
+            if (normalizeRemote(origin) !== expectedRemote) {
+                return null;
+            }
+        }
+        const resolved = await resolveExistingDirectoryPath(candidate);
+        return isSubPath(allowedRoot, resolved) ? resolved : null;
+    }
+    async ensureBaseBranch(repoPath, baseBranch) {
+        if (await this.gitRefExists(repoPath, `refs/heads/${baseBranch}`)) {
+            return;
+        }
+        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.`);
+        }
+        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;
+        }
+        throw new Error(`Base branch '${baseBranch}' was not found locally or on origin.`);
+    }
+    async gitRefExists(repoPath, gitRef) {
+        return this.git.run(repoPath, ["show-ref", "--verify", "--quiet", gitRef]).then(() => true).catch(() => false);
+    }
     async ensureGitIdentity(repoPath) {
         await this.git.run(repoPath, ["config", "user.email", "forge-bridge@forge.local"]);
         await this.git.run(repoPath, ["config", "user.name", "Forge Bridge"]);
     }
 }
+function managedRepoRoot(allowedRoot) {
+    return path.join(allowedRoot, ".forge-worktrees", "_repos");
+}
+function resolveWorktreeRoot(allowedRoot, repoPath) {
+    const baseName = path.basename(repoPath);
+    return isSubPath(managedRepoRoot(allowedRoot), repoPath)
+        ? path.join(allowedRoot, ".forge-worktrees", baseName)
+        : path.join(path.dirname(repoPath), ".forge-worktrees", baseName);
+}
+function isCloneableRemote(remoteUrl) {
+    const trimmed = remoteUrl?.trim() ?? "";
+    if (trimmed.length === 0 || trimmed.startsWith("local://")) {
+        return false;
+    }
+    return trimmed.startsWith("git@") || trimmed.includes("://") || path.isAbsolute(trimmed);
+}
 export function normalizeBranchName(value, fallback) {
     const branch = (value?.trim() || fallback).trim();
     if (branch.length === 0 ||
@@ -133,7 +240,62 @@ async function gitMetadataExists(repoPath, allowedRoot) {
     const resolvedGitDir = await resolveExistingDirectoryPath(gitDirPath);
     return isSubPath(allowedRoot, resolvedGitDir);
 }
+async function pathExists(inputPath) {
+    return fs.stat(inputPath).then(() => true).catch(() => false);
+}
 async function directoryExists(inputPath) {
     const stat = await fs.stat(inputPath).catch(() => null);
     return stat?.isDirectory() ?? false;
 }
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function isSinglePathSegment(value) {
+    return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\");
+}
+function normalizeRemote(remoteUrl) {
+    const trimmed = remoteUrl?.trim() ?? "";
+    if (trimmed.length === 0) {
+        return "";
+    }
+    const gitHubSsh = /^git@github\.com:(.+)$/i.exec(trimmed);
+    if (gitHubSsh) {
+        return stripGitSuffix(`https://github.com/${gitHubSsh[1]}`).toLowerCase();
+    }
+    if (path.isAbsolute(trimmed)) {
+        return normalizeLocalPath(trimmed);
+    }
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol === "file:") {
+            return normalizeLocalPath(normalizeFileUrlPath(url));
+        }
+        url.username = "";
+        url.password = "";
+        url.hash = "";
+        return stripGitSuffix(url.toString().replace(/\/$/, "")).toLowerCase();
+    }
+    catch {
+        return stripGitSuffix(trimmed.replace(/\\/g, "/")).toLowerCase();
+    }
+}
+function stripGitSuffix(value) {
+    return value.replace(/\.git$/i, "").replace(/\/$/, "");
+}
+function normalizeFileUrlPath(url) {
+    const pathname = decodeURIComponent(url.pathname);
+    return /^\/[A-Za-z]:[\\/]/.test(pathname) ? pathname.slice(1) : pathname;
+}
+function normalizeLocalPath(value) {
+    const normalized = path.resolve(value).replace(/\\/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/worktree/worktree.types.d.ts

@@ -1,10 +1,13 @@
-import type { DispatchRepo, DispatchWorkItem } from "../session/session.types.js";
+import type { DispatchRepo, DispatchWorkItem, DispatchResolvedArtifact } from "../session/session.types.js";
+import type { WarmDependenciesResult } from "./dependency-warmer.js";
 export interface WorktreePrepareRequest {
     readonly repo: DispatchRepo;
     readonly workItem: DispatchWorkItem;
     readonly baseBranch: string;
     readonly allowedRepoRoot: string;
     readonly cleanupWorktrees: boolean;
+    readonly artifacts: readonly DispatchResolvedArtifact[];
+    readonly warmPathOverrides?: readonly string[];
 }
 export interface WorktreeHandle {
     readonly repoPath: string;
@@ -12,4 +15,5 @@ export interface WorktreeHandle {
     readonly branchName: string;
     readonly baseBranch: string;
     readonly cleanupWorktrees: boolean;
+    readonly dependencyWarm?: WarmDependenciesResult;
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.1-dev.242bb53ef13f",
+  "version": "0.1.1-dev.2ac58b6f94ce",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
-    "forge-bridge": "./dist/cli/bin.js"
+    "forge-bridge": "dist/cli/bin.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",