@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599 → 0.1.1-dev.2bc1e7f19b3a

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

@@ -10,4 +10,5 @@ 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

@@ -65,13 +65,15 @@ export class BridgeSessionService {
                         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 {

package/dist/session/session.types.d.ts

@@ -18,6 +18,7 @@ export interface DispatchResolvedArtifact {
     readonly scope: string;
     readonly body: string;
     readonly contentHash: string;
+    readonly version: number;
     readonly lane?: string | null;
     readonly event?: string | null;
 }
@@ -101,6 +102,7 @@ export interface RunnerDispatchArtifact {
     readonly report: string;
     readonly producedBy: string;
     readonly status: string;
+    readonly phase?: string | null;
 }
 export interface RunOnceResultPacket {
     readonly schemaVersion: 1;
@@ -109,6 +111,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

@@ -153,6 +153,7 @@ function parseArtifacts(value) {
             scope: requiredString(artifact, "scope"),
             body: optionalString(artifact, "body") ?? "",
             contentHash: requiredString(artifact, "contentHash"),
+            version: optionalPositiveInteger(artifact, "version") ?? 1,
             lane: optionalString(artifact, "lane"),
             event: optionalString(artifact, "event")
         };
@@ -188,6 +189,16 @@ function requiredBoolean(source, key) {
     }
     return value;
 }
+function optionalPositiveInteger(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${key} must be a positive integer when provided.`);
+    }
+    return value;
+}
 function requiredNumber(source, key) {
     const value = source[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {

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.1-dev.03b8ba168599";
+export declare const forgeBridgeVersion = "0.1.1-dev.2bc1e7f19b3a";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.03b8ba168599";
+export const forgeBridgeVersion = "0.1.1-dev.2bc1e7f19b3a";

package/dist/worktree/artifact-injector.d.ts

@@ -8,4 +8,4 @@ export declare function buildSpecBody(laneCommand: DispatchResolvedArtifact, wor
     readonly title: string;
     readonly description: string;
     readonly acceptanceCriteria: string;
-}): string;
+}, phase?: string): string;

package/dist/worktree/artifact-injector.js

@@ -15,11 +15,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,10 +29,7 @@ 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 normalizedPhase = phase.trim().toLowerCase().replace(/-/g, "_");
     if (normalizedPhase === "rework") {
         return "rework-prompt";
     }
@@ -43,12 +42,13 @@ export function resolveCommandSlug(lane, phase) {
             return "dev-prompt";
     }
 }
-export function buildSpecBody(laneCommand, workItem) {
+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/package.json

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