@loucompanion/forge-bridge 0.1.1-dev.8dcbc6245e51 → 0.1.1-dev.9acab970e5d1

package/dist/worktree/artifact-injector.js

@@ -1,11 +1,20 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+const DEBUG_OPERATIONAL_SKILLS = new Set(["debug-repro", "debug-root-cause", "debug-fix", "debug-regression"]);
+const DEBUG_OPERATIONAL_HOOKS = new Set(["debug-gate", "debug-tool-hook", "debug-rework"]);
 export async function injectWorktreeArtifacts(worktreePath, artifacts) {
     for (const artifact of artifacts) {
         await writeArtifact(worktreePath, artifact);
     }
 }
+export function filterArtifactsForLane(artifacts, lane, phase) {
+    if (lane.trim().toLowerCase() !== "debug") {
+        return artifacts;
+    }
+    const commandSlug = resolveCommandSlug(lane, phase).toLowerCase();
+    return artifacts.filter((artifact) => shouldInjectDebugArtifact(artifact, commandSlug));
+}
 export async function writeArtifact(worktreePath, artifact) {
     const writtenHash = sha256(artifact.body);
     if (writtenHash !== artifact.contentHash.toLowerCase()) {
@@ -15,11 +24,13 @@ export async function writeArtifact(worktreePath, artifact) {
     const scope = safeArtifactSegment("scope", artifact.scope);
     const slug = safeArtifactSegment("slug", artifact.slug);
     const forgeRoot = path.resolve(worktreePath, ".forge");
-    const targetDir = path.resolve(forgeRoot, kindFolder, scope);
-    assertInside(forgeRoot, targetDir, "Artifact directory");
-    await fs.mkdir(targetDir, { recursive: true });
-    const filePath = path.resolve(targetDir, `${slug}.md`);
+    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) {
@@ -27,14 +38,15 @@ export function selectLaneCommand(artifacts, lane, phase) {
     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";
+    const normalizedLane = lane.trim().toLowerCase();
+    if (normalizedLane === "debug") {
+        return "debug-prompt";
     }
+    const normalizedPhase = phase.trim().toLowerCase().replace(/-/g, "_");
     if (normalizedPhase === "rework") {
         return "rework-prompt";
     }
-    switch (lane.trim().toLowerCase()) {
+    switch (normalizedLane) {
         case "architect":
             return "architect-prompt";
         case "qa":
@@ -43,12 +55,29 @@ export function resolveCommandSlug(lane, phase) {
             return "dev-prompt";
     }
 }
-export function buildSpecBody(laneCommand, workItem) {
+function shouldInjectDebugArtifact(artifact, commandSlug) {
+    if (artifact.scope.trim().toLowerCase() !== "operational") {
+        return false;
+    }
+    const slug = artifact.slug.trim().toLowerCase();
+    switch (normalizedArtifactKind(artifact.kind)) {
+        case "command":
+            return slug === commandSlug;
+        case "skill":
+            return DEBUG_OPERATIONAL_SKILLS.has(slug);
+        case "hook":
+            return DEBUG_OPERATIONAL_HOOKS.has(slug);
+        default:
+            return true;
+    }
+}
+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}
 ---
 

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

@@ -7,6 +7,8 @@ export declare class GitWorktreeService implements WorktreeService {
     prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
     release(handle: WorktreeHandle): Promise<void>;
     private resolveRepoPath;
+    private findExistingRepoPath;
+    private resolveMatchingRepo;
     private ensureBaseBranch;
     private gitRefExists;
     private ensureGitIdentity;

package/dist/worktree/worktree.service.js

@@ -2,7 +2,7 @@ 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 { filterArtifactsForLane, injectWorktreeArtifacts } from "./artifact-injector.js";
 import { warmWorktreeDependencies } from "./dependency-warmer.js";
 export class GitWorktreeService {
     git;
@@ -18,7 +18,7 @@ export class GitWorktreeService {
         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)) {
@@ -37,8 +37,9 @@ export class GitWorktreeService {
             }
         }
         await this.ensureGitIdentity(resolvedWorktreePath);
-        if (request.artifacts.length > 0) {
-            await injectWorktreeArtifacts(resolvedWorktreePath, request.artifacts);
+        const artifacts = filterArtifactsForLane(request.artifacts, request.lane, request.phase);
+        if (artifacts.length > 0) {
+            await injectWorktreeArtifacts(resolvedWorktreePath, artifacts);
         }
         const dependencyWarm = await warmWorktreeDependencies({
             baseCheckoutPath: repoPath,
@@ -78,7 +79,11 @@ 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))) {
             const repoPathExists = await pathExists(repoPath);
             if (repoPathExists) {
@@ -109,6 +114,46 @@ 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;
@@ -132,6 +177,15 @@ export class GitWorktreeService {
         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://")) {
@@ -194,3 +248,55 @@ 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

@@ -4,6 +4,8 @@ export interface WorktreePrepareRequest {
     readonly repo: DispatchRepo;
     readonly workItem: DispatchWorkItem;
     readonly baseBranch: string;
+    readonly lane: string;
+    readonly phase: string;
     readonly allowedRepoRoot: string;
     readonly cleanupWorktrees: boolean;
     readonly artifacts: readonly DispatchResolvedArtifact[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.1-dev.8dcbc6245e51",
+  "version": "0.1.1-dev.9acab970e5d1",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",