agentplugged 0.0.1 → 1.0.0

package/dist/forge-follow.js

@@ -0,0 +1,231 @@
+import { hr as CHECKPOINT_CLOSED_EVENT_TYPES, in as MERGE_EVENT_TYPES, pi as CHECKPOINT_EVENT_TYPES } from "./webauthn.js";
+import { $s as storyReviewDone, Bl as loadMethodConfig, Du as checkpointPayload, Ku as METHOD_CONFIG_PATH, Mt as storyWeight, Ou as truncate, Sl as storiesIn, c as project, ds as settledPoints, fr as targetBranch, gu as isSkipped, ln as resolvePullRequestSettings, lr as deliveryRemote, vc as forgeRepositoryOf, wr as storyFiles, xt as removeMergedWorktree, yc as isRepositoryPullRequest } from "./agent-commands.js";
+//#region ../../packages/core/dist/journey/merge-point.js
+/** True when a merge point was opened for the story since it went to review (open, or answered). */
+function openedSince(checkpoints, id, since) {
+	const from = Date.parse(since);
+	return checkpoints.some((checkpoint) => checkpoint.type === "story" && checkpoint.source === "merge" && checkpoint.story === id && !(Date.parse(checkpoint.opened_at) < from));
+}
+/**
+* The stories in review that the engine opens a merge point for: the review skipped, or (a security
+* review the creator skipped while the quality review was in) the review closed by that skip, and no
+* merge point opened since the story went to review.
+*/
+function dueMergePoints(state) {
+	const stories = state.stories ?? {};
+	const checkpoints = Object.values(state.checkpoints ?? {});
+	const due = [];
+	for (const [id, story] of Object.entries(stories)) {
+		if (story.started === void 0 || story.merged !== void 0) continue;
+		if (story.status !== "in_review" || story.status_by === null) continue;
+		const reviewSkipped = isSkipped(state, "story_review", id);
+		const securitySkipped = isSkipped(state, "story_security", id);
+		const ciSkipped = isSkipped(state, "story_ci", id);
+		if (!reviewSkipped && !(securitySkipped && storyReviewDone(story, void 0, ciSkipped))) continue;
+		if (openedSince(checkpoints, id, story.status_by.at)) continue;
+		due.push({
+			story: id,
+			skipped: [...reviewSkipped ? ["review"] : securitySkipped ? ["security"] : [], ...ciSkipped ? ["ci"] : []]
+		});
+	}
+	return due.sort((a, b) => a.story < b.story ? -1 : a.story > b.story ? 1 : 0);
+}
+/** What each skipped check is called in the creator's question. */
+const WORDS = {
+	review: "its independent review",
+	security: "its security review",
+	ci: "its CI"
+};
+/** The merge checkpoint the engine opens for such a story (source `merge`, a medium risk). */
+function skippedMergeCheckpoint(point) {
+	const what = point.skipped.map((entry) => WORDS[entry] ?? entry).join(" and ");
+	return {
+		...checkpointPayload({
+			type: "story",
+			risk: "medium",
+			title: truncate(`Merge story ${point.story}`, 120),
+			summary: truncate(`You skipped ${what} for story ${point.story}: it is ready to merge as it stands. Approve and the engine merges its pull request into the main branch with your forge's tool, then removes its worktree (a git revert of the merge undoes it); ask for changes to send it back to its developer with your note.`, 2e3)
+		}),
+		source: "merge"
+	};
+}
+//#endregion
+//#region ../../packages/core/dist/merge/forge-follow.js
+/**
+* The engine follows the forge. What the creator does on GitHub or GitLab is their own
+* gesture, never one to "regularise": a pull request merged by hand is recorded as the creator's
+* merge (`story.merged`, source `forge`, with the account, the date and the commit the forge gives),
+* the story is done, and the points that waited for it are closed. The points whose object is
+* settled (a story merged, a review done again, a request replaced) are closed by the engine with
+* their reason (`checkpoint.closed`), so that none is ever shown to the creator.
+*
+* Read at `next`, `get_state` and `check_ci`. Best effort: it never throws, never asks anything,
+* and a forge that cannot be reached leaves things as they are.
+*/
+const DEFAULT_THROTTLE_MS = 2e4;
+/** When the forge was last read, by journal (the journal object stands for the product here). */
+const lastRead = /* @__PURE__ */ new WeakMap();
+/** The stories whose pull request the forge may have merged: started, not merged, with one. */
+function followable(state) {
+	return Object.entries(storiesIn(state)).filter(([, story]) => story.started !== void 0 && story.merged === void 0 && story.pull_request !== void 0);
+}
+/** The `story.merged` payload of a pull request the forge shows merged, or undefined. */
+async function forgeMerge(context, config, state, id, story) {
+	const forge = context.storyForge;
+	const started = story.started;
+	const pr = story.pull_request;
+	if (forge?.pullRequest === void 0 || started === void 0 || pr === void 0) return;
+	const inspection = await forge.inspect(started.branch, started.base);
+	if (!inspection.repository) return void 0;
+	const remote = deliveryRemote(inspection.remotes, started.base_ref);
+	if (remote === void 0) return void 0;
+	const located = forgeRepositoryOf(remote.url);
+	if (!("forge" in located) || located.forge !== pr.forge) return void 0;
+	if (!isRepositoryPullRequest(located, pr.url, pr.number)) return void 0;
+	const current = await forge.pullRequest(located, pr.number);
+	if (current.state !== "merged") return void 0;
+	if (current.base !== void 0 && current.base !== null && current.base !== targetBranch(started.base_ref, inspection.remotes)) return;
+	const commit = current.head ?? pr.head;
+	const settings = await resolvePullRequestSettings(config, context.mainBranch);
+	const files = await storyFiles(context, started, commit).catch(() => void 0);
+	const weight = await storyWeight(context, files?.diff, commit);
+	const checkpoints = state.checkpoints ?? {};
+	const open = Object.values(checkpoints).find((checkpoint) => checkpoint.story === id && checkpoint.source === "merge" && checkpoint.status === "open");
+	return {
+		...open === void 0 ? {} : { checkpoint: open.id },
+		forge: pr.forge,
+		pr: pr.number,
+		url: pr.url,
+		commit,
+		...current.merge_commit === null ? {} : { merge_commit: current.merge_commit },
+		method: settings.merge_method,
+		files: files?.files ?? [],
+		...files?.truncated === true ? { files_truncated: true } : {},
+		...weight === void 0 ? {} : { weight },
+		source: "forge",
+		already: true,
+		merged_by: current.merged_by ?? "forge",
+		merged_at: current.merged_at ?? new Date((context.now ?? Date.now)()).toISOString()
+	};
+}
+/**
+* The stories whose working copy is gone from the disk, among those a permission point still open
+* is about: started, not merged, no folder checked out and nothing at the expected
+* place. Only the disk of this machine says so, so the engine reads it here; a repository it cannot
+* read leaves every story as it is (never a point closed on a doubt).
+*/
+async function goneWorktrees(context, state) {
+	const workspace = context.storyWorkspace;
+	const gone = /* @__PURE__ */ new Set();
+	if (workspace === void 0) return gone;
+	const stories = storiesIn(state);
+	const checkpoints = state.checkpoints ?? {};
+	const asked = /* @__PURE__ */ new Set();
+	for (const checkpoint of Object.values(checkpoints)) if (checkpoint.status === "open" && checkpoint.type === "permission" && checkpoint.story !== null) asked.add(checkpoint.story);
+	for (const id of asked) {
+		const started = Object.hasOwn(stories, id) ? stories[id]?.started : void 0;
+		if (started === void 0 || stories[id]?.merged !== void 0) continue;
+		try {
+			const seen = await workspace.inspect({
+				id,
+				branch: started.branch,
+				path: ""
+			});
+			if (seen.repository && seen.branch !== null && seen.checkedOut === null && !seen.target.exists) gone.add(id);
+		} catch {}
+	}
+	return gone;
+}
+/**
+* Reads the forge and the journal, and writes what follows: the merges the creator did on the forge,
+* then the closing of the points whose object is settled. Returns how many events it wrote (0 when
+* nothing changed or anything went wrong). `force` reads the forge even if it was read a moment ago.
+*/
+async function followForge(context, options = {}) {
+	try {
+		const journal = context.journal;
+		if (journal === void 0 || !await context.files.exists(METHOD_CONFIG_PATH)) return 0;
+		const loaded = await loadMethodConfig(context.files);
+		if (!("config" in loaded)) return 0;
+		const config = loaded.config;
+		const product = config.product_id ?? await journal.productId();
+		if (product === null) return 0;
+		const clock = context.now ?? Date.now;
+		const throttle = context.forgeThrottleMs ?? DEFAULT_THROTTLE_MS;
+		const before = lastRead.get(journal);
+		const readForge = options.force === true || before === void 0 || clock() - before >= throttle;
+		let written = 0;
+		const merged = [];
+		if (readForge) {
+			lastRead.set(journal, clock());
+			const state = (await project(context, config, await journal.list())).state;
+			const drafts = [];
+			for (const [id, story] of followable(state)) {
+				const payload = await forgeMerge(context, config, state, id, story).catch(() => void 0);
+				if (payload === void 0) continue;
+				drafts.push({
+					type: MERGE_EVENT_TYPES.merged,
+					actor: { kind: "system" },
+					product,
+					story: id,
+					provenance: "trusted",
+					payload
+				});
+				merged.push({
+					id,
+					branch: story.started.branch
+				});
+			}
+			if (drafts.length > 0) {
+				const events = await journal.appendAll(drafts, { precondition: async (current) => {
+					const latest = (await project(context, config, current)).state;
+					for (const entry of merged) if (storiesIn(latest)[entry.id]?.merged !== void 0) throw new Error("merged meanwhile");
+				} });
+				written += events.length;
+			}
+		}
+		const state = (await project(context, config, await journal.list())).state;
+		const gone = await goneWorktrees(context, state);
+		const settledContext = {
+			now: clock(),
+			gone: (story) => gone.has(story)
+		};
+		const settled = settledPoints(state, settledContext);
+		if (settled.length > 0) {
+			const events = await journal.appendAll(settled.map((point) => ({
+				type: CHECKPOINT_CLOSED_EVENT_TYPES.closed,
+				actor: { kind: "system" },
+				product,
+				provenance: "trusted",
+				payload: {
+					checkpoint: point.checkpoint,
+					reason: point.reason,
+					...point.ref === void 0 ? {} : { ref: point.ref }
+				}
+			})));
+			written += events.length;
+		}
+		const due = dueMergePoints(state);
+		if (due.length > 0) {
+			const events = await journal.appendAll(due.map((point) => ({
+				type: CHECKPOINT_EVENT_TYPES.opened,
+				actor: { kind: "system" },
+				product,
+				story: point.story,
+				provenance: "trusted",
+				payload: { ...skippedMergeCheckpoint(point) }
+			})), { precondition: async (current) => {
+				const latest = (await project(context, config, current)).state;
+				const still = new Set(dueMergePoints(latest).map((point) => point.story));
+				if (!due.every((point) => still.has(point.story))) throw new Error("opened meanwhile");
+			} });
+			written += events.length;
+		}
+		for (const entry of merged) await removeMergedWorktree(context, entry.id, entry.branch);
+		return written;
+	} catch {
+		return 0;
+	}
+}
+//#endregion
+export { followForge };