@savvy-web/silk-effects 5.4.0 → 5.5.1

package/repos/services/config-store.js

@@ -1,7 +1,7 @@
 import { MANIFEST_PATH, REPOS_DIR } from "../constants.js";
 import { ReposConfigError } from "../errors.js";
 import { ReposManifestFile } from "../schemas/manifest.js";
-import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import { Clock, Context, Effect, FileSystem, Layer, Option, Path, Schedule, Schema } from "effect";
 
 //#region src/repos/services/config-store.ts
 /**
@@ -71,10 +71,44 @@ var ReposConfigStore = class extends Context.Service()("@savvy-web/silk-effects/
 				kind: "invalid"
 			})));
 		});
+		const lockSchedule = Schedule.exponential("25 millis").pipe(Schedule.upTo({ duration: "2 seconds" }));
+		const LOCK_MAX_AGE_MS = 6e4;
+		const acquireLock = (root) => Effect.gen(function* () {
+			const lockPath = `${manifestPath(root)}.lock`;
+			const dir = path.join(root, REPOS_DIR);
+			yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.mapError((cause) => new ReposConfigError({
+				path: lockPath,
+				reason: `mkdir failed: ${String(cause)}`,
+				kind: "invalid"
+			})));
+			yield* Effect.gen(function* () {
+				const info = yield* fs.stat(lockPath).pipe(Effect.option);
+				if (Option.isSome(info) && Option.isSome(info.value.mtime)) {
+					if ((yield* Clock.currentTimeMillis) - info.value.mtime.value.getTime() >= LOCK_MAX_AGE_MS) yield* fs.remove(lockPath).pipe(Effect.ignore);
+				}
+				yield* Effect.scoped(fs.open(lockPath, { flag: "wx" })).pipe(Effect.asVoid);
+			}).pipe(Effect.retry({
+				schedule: lockSchedule,
+				while: (error) => error.reason._tag === "AlreadyExists"
+			}), Effect.mapError((cause) => new ReposConfigError({
+				path: lockPath,
+				reason: `timed out acquiring lock after 2s at ${lockPath}: ${String(cause)}. If no other savvy process is running, a previous run likely crashed while holding it -- remove ${lockPath} and retry.`,
+				kind: "invalid"
+			})));
+		});
+		const releaseLock = (root) => fs.remove(`${manifestPath(root)}.lock`).pipe(Effect.ignore);
+		const update = (root, fn) => Effect.scoped(Effect.gen(function* () {
+			yield* Effect.acquireRelease(acquireLock(root), () => releaseLock(root));
+			const result = fn(yield* read(root).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? Effect.succeed({ repos: {} }) : Effect.fail(error))));
+			const next = Effect.isEffect(result) ? yield* result : result;
+			yield* write(root, next);
+			return next;
+		}));
 		return {
 			exists,
 			read,
-			write
+			write,
+			update
 		};
 	}));
 };

package/repos/services/drift.js

@@ -0,0 +1,168 @@
+import { REPOS_DIR } from "../constants.js";
+import { GitSubmoduleError } from "../errors.js";
+import { RepoDrift, ReposDriftReport } from "../schemas/drift.js";
+import { ReposConfigStore } from "./config-store.js";
+import { Context, Effect, FileSystem, Layer, Option, Path, Result } from "effect";
+import { Git, Gitmodules } from "@effected/git";
+
+//#region src/repos/services/drift.ts
+/**
+* Reconciles the four authorities a vendored repo's state is spread across —
+* the manifest, `.gitmodules`, the worktree, and `git submodule status` —
+* and reports every disagreement found. Read-only: no staging, no lockdown
+* interaction, so it runs unmodified against a locked (`ReposLockdown`)
+* tree.
+* @public
+*/
+var ReposDrift = class extends Context.Service()("@savvy-web/silk-effects/ReposDrift") {
+	/**
+	* Production implementation of {@link ReposDrift}.
+	* @public
+	*/
+	static layer = Layer.effect(this, Effect.gen(function* () {
+		const configStore = yield* ReposConfigStore;
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const git = yield* Git;
+		/** Map any typed `@effected/git` failure onto this module's `GitSubmoduleError`. */
+		const asSubmoduleError = (command, cwd) => (error) => new GitSubmoduleError({
+			command,
+			cwd,
+			reason: error.message
+		});
+		const isPresent = (repoPath) => fs.readDirectory(repoPath).pipe(Effect.map((files) => files.length > 0), Effect.orElseSucceed(() => false));
+		const check = (root) => Effect.gen(function* () {
+			const manifest = yield* configStore.read(root);
+			const manifestEntries = Object.entries(manifest.repos);
+			const gitmodulesPath = path.join(root, ".gitmodules");
+			const gitmodulesText = yield* fs.readFileString(gitmodulesPath).pipe(Effect.map(Option.some), Effect.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(asSubmoduleError("read .gitmodules", gitmodulesPath)(error))));
+			if (Option.isNone(gitmodulesText)) {
+				const drifts = manifestEntries.map(([name, entry]) => RepoDrift.make({
+					name,
+					kind: "unregisteredManifestEntry",
+					detail: `manifest entry "${name}" has no corresponding .gitmodules section (.gitmodules is absent)`,
+					manifestValue: entry.url
+				}));
+				return ReposDriftReport.make({
+					drifts,
+					clean: drifts.length === 0
+				});
+			}
+			const parsed = Gitmodules.parseResult(gitmodulesText.value);
+			if (Result.isFailure(parsed)) return ReposDriftReport.make({
+				drifts: [RepoDrift.make({
+					name: ".gitmodules",
+					kind: "gitmodulesUnparsable",
+					detail: `.gitmodules failed to parse: ${parsed.failure.message}`
+				})],
+				clean: false
+			});
+			const gitmodules = parsed.success;
+			const statuses = yield* git.submoduleStatus(root).pipe(Effect.mapError(asSubmoduleError("git submodule status", root)));
+			const statusByPath = new Map(statuses.map((status) => [status.path, status]));
+			const drifts = [];
+			const matchedSectionNames = /* @__PURE__ */ new Set();
+			const pairedByName = /* @__PURE__ */ new Map();
+			for (const [name] of manifestEntries) {
+				const expectedPath = `${REPOS_DIR}/${name}`;
+				const nameMatch = gitmodules.entries.find((candidate) => candidate.name === expectedPath && !matchedSectionNames.has(candidate.name));
+				if (nameMatch) {
+					matchedSectionNames.add(nameMatch.name);
+					pairedByName.set(name, {
+						section: nameMatch,
+						viaPath: false
+					});
+				}
+			}
+			for (const [name] of manifestEntries) {
+				if (pairedByName.has(name)) continue;
+				const expectedPath = `${REPOS_DIR}/${name}`;
+				const pathMatch = gitmodules.entries.find((candidate) => candidate.path === expectedPath && !matchedSectionNames.has(candidate.name));
+				if (pathMatch) {
+					matchedSectionNames.add(pathMatch.name);
+					pairedByName.set(name, {
+						section: pathMatch,
+						viaPath: true
+					});
+				}
+			}
+			for (const [name, entry] of manifestEntries) {
+				const expectedPath = `${REPOS_DIR}/${name}`;
+				const paired = pairedByName.get(name);
+				if (!paired) {
+					drifts.push(RepoDrift.make({
+						name,
+						kind: "unregisteredManifestEntry",
+						detail: `manifest entry "${name}" has no corresponding .gitmodules section`,
+						manifestValue: entry.url
+					}));
+					continue;
+				}
+				const { section, viaPath } = paired;
+				const pathMatch = viaPath ? section : void 0;
+				if (pathMatch) drifts.push(RepoDrift.make({
+					name,
+					kind: "pathMismatch",
+					detail: `manifest entry "${name}" paired with .gitmodules section "${pathMatch.name}" by its path "${expectedPath}" -- the section name diverges from the manifest entry name`,
+					manifestValue: name,
+					observedValue: pathMatch.name
+				}));
+				else if (section.path !== expectedPath) drifts.push(RepoDrift.make({
+					name,
+					kind: "pathMismatch",
+					detail: `manifest entry "${name}" expects path "${expectedPath}" but .gitmodules records "${section.path}"`,
+					manifestValue: expectedPath,
+					observedValue: section.path
+				}));
+				if (section.url !== entry.url) drifts.push(RepoDrift.make({
+					name,
+					kind: "urlMismatch",
+					detail: `manifest entry "${name}" expects url "${entry.url}" but .gitmodules records "${section.url}"`,
+					manifestValue: entry.url,
+					observedValue: section.url
+				}));
+				if (section.shallow !== true) drifts.push(RepoDrift.make({
+					name,
+					kind: "missingShallow",
+					detail: `.gitmodules does not record submodule.${section.name}.shallow = true`,
+					observedValue: section.shallow === void 0 ? "unset" : String(section.shallow)
+				}));
+				const repoPath = path.join(root, section.path);
+				const present = yield* isPresent(repoPath);
+				const status = statusByPath.get(section.path);
+				if (!present || status?.state === "uninitialized") drifts.push(RepoDrift.make({
+					name,
+					kind: "missingWorktree",
+					detail: `manifest entry "${name}" expects a checked-out worktree at "${section.path}" but none is present`
+				}));
+				else if (status?.state === "outOfSync") drifts.push(RepoDrift.make({
+					name,
+					kind: "checkoutDiverged",
+					detail: `the worktree checked out at "${section.path}" no longer matches the commit recorded in the superproject index`
+				}));
+				else if (status?.state === "conflict") drifts.push(RepoDrift.make({
+					name,
+					kind: "checkoutDiverged",
+					detail: `submodule index entry for "${section.path}" is in an unresolved merge conflict`
+				}));
+			}
+			for (const section of gitmodules.entries) {
+				if (matchedSectionNames.has(section.name)) continue;
+				drifts.push(RepoDrift.make({
+					name: section.name,
+					kind: "orphanGitmodulesEntry",
+					detail: `.gitmodules section "${section.name}" has no corresponding manifest entry`,
+					observedValue: section.path
+				}));
+			}
+			return ReposDriftReport.make({
+				drifts,
+				clean: drifts.length === 0
+			});
+		});
+		return { check };
+	}));
+};
+
+//#endregion
+export { ReposDrift };