@shivaedev/work-fleet 0.3.0 → 0.5.0

package/src/host/configFile.ts

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import { HostConfig, HostConfigRejected, HostFailure, resolveHost } from "#host/config.ts";
+import { CONFIG_FILE } from "#host/defaults.ts";
+
+export const readHostConfig = Effect.fn("FleetHost.readHostConfig")(function* (file: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const text = yield* fs
+		.readFileString(file)
+		.pipe(Effect.mapError(() => new HostConfigRejected({ file, message: `Fleet host configuration is missing or unreadable: ${file}` })));
+	const config = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(HostConfig))(text).pipe(
+		Effect.mapError((error) => {
+			const field = SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues[0]?.path?.map(String).join(".");
+			return new HostConfigRejected({
+				...(field === undefined || field === "" ? {} : { field }),
+				file,
+				message: `Fleet host configuration ${file} is invalid: ${error.message}`,
+			});
+		}),
+	);
+	if (config.provider === "cloud" && (config.cloud === undefined || config.worker === undefined)) {
+		return yield* new HostConfigRejected({
+			field: config.cloud === undefined ? "cloud" : "worker",
+			file,
+			message: `Fleet host configuration ${file} selects provider "cloud" without cloud and worker settings`,
+		});
+	}
+	return config;
+});
+
+export const loadHost = Effect.fn("FleetHost.loadHost")(function* (board: string, configPath?: string) {
+	const path = yield* Path.Path;
+	const boardDir = path.resolve(board);
+	const file = configPath === undefined ? path.join(boardDir, CONFIG_FILE) : path.resolve(configPath);
+	const config = yield* readHostConfig(file).pipe(Effect.mapError((rejected) => new HostFailure({ message: rejected.message })));
+	return resolveHost(boardDir, config, file);
+});

package/src/host/configSettings.ts

@@ -12,6 +12,7 @@ export const RELOADABLE_SETTINGS = [
 	"launch",
 	"openPullRequests",
 	"quota",
+	"readRetryMs",
 	"stallMinutes",
 	"worker.reviewerGuidance",
 	"worker.workerGuidance",
@@ -50,6 +51,7 @@ function appliedSettings(host: FleetHost): HostConfig {
 		...(host.openPullRequests === undefined ? {} : { openPullRequests: host.openPullRequests }),
 		provider: host.provider,
 		quota: host.quota,
+		readRetryMs: host.readRetryMs,
 		repository: host.repository,
 		...(host.result === undefined ? {} : { result: host.result }),
 		stallMinutes: host.stallMinutes,

package/src/host/daemonHandlers.ts

@@ -7,10 +7,10 @@ import { ClientContract } from "#host/daemonContract.ts";
 import { daemonDiagnostics } from "#host/daemonDiagnostics.ts";
 import { daemonSnapshots } from "#host/daemonSnapshots.ts";
 import { dispatchRequests } from "#host/dispatchRequests.ts";
+import { fleetStatus } from "#host/fleetStatus.ts";
 import { LiveConfig } from "#host/liveConfig.ts";
 import { nameStoredThreads } from "#host/nameThreads.ts";
 import { decisionResponses, releaseItems } from "#host/releaseWork.ts";
-import { fleetStatus } from "#host/status.ts";
 
 export const daemonHandlers = Effect.fn("FleetDaemon.daemonHandlers")(function* (host: FleetHost) {
 	const scope = yield* Effect.scope;

package/src/host/{status.ts → fleetStatus.ts}

@@ -2,7 +2,6 @@ import { Effect, Schema } from "effect";
 import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
 import { views } from "#engine/views.ts";
 import type { FleetHost } from "#host/config.ts";
-import { renderStatus as render } from "#host/renderStatus.ts";
 import { FleetRecord } from "#model.ts";
 import { dispatchStore } from "#storage/dispatchStore.ts";
 import { recordModel } from "#storage/model.ts";
@@ -10,10 +9,6 @@ import { readRecords } from "#storage/readRecords.ts";
 import { recordShape } from "#storage/recordShape.ts";
 import { recordValues } from "#storage/recordValue.ts";
 
-export function renderStatus(current: Parameters<typeof render>[0]) {
-	return render(current);
-}
-
 export const fleetStatus = Effect.fn("FleetHost.fleetStatus")(function* (host: FleetHost, workId?: string) {
 	const repository = yield* makeRepository(recordModel(), {
 		idColumn: "work_id",

package/src/host/liveConfig.ts

@@ -15,7 +15,8 @@ import {
 	Stream,
 	SubscriptionRef,
 } from "effect";
-import { type FleetHost, HostConfig, HostConfigRejected, type HostFailure, readHostConfig, resolveHost } from "#host/config.ts";
+import { type FleetHost, HostConfig, HostConfigRejected, type HostFailure, resolveHost } from "#host/config.ts";
+import { readHostConfig } from "#host/configFile.ts";
 import { changedSettings, withReloadable } from "#host/configSettings.ts";
 import { hostGuidance } from "#host/guidance.ts";
 

package/src/host/releaseWork.ts

@@ -10,7 +10,7 @@ import { recordDecisionResponse } from "#host/recordDecisionResponse.ts";
 import { executing } from "#model.ts";
 
 const { searchSnapshot, watchChanges } = board;
-const { ResponseConfig, Responses } = responses;
+const { Responses, Workspace, WorkspaceConfig } = responses;
 
 export function releaseWork(host: FleetHost, workIds: readonly string[], parts: HostParts = productionParts(host)) {
 	return withDecisionResponses(host, releaseItems(host, workIds)).pipe(Effect.provide(hostLayer(host, parts)));
@@ -27,7 +27,10 @@ export function decisionResponses(host: FleetHost) {
 			const changes = yield* watchChanges(host.boardDir);
 			const index = (yield* searchSnapshot(host.boardDir, undefined, changes)).pipe(Effect.provide(NodeServices.layer));
 			yield* index.pipe(Effect.ignore, Effect.forkScoped);
-			return Responses.layer.pipe(Layer.provide(Layer.succeed(ResponseConfig, { changes, enabled: true, index, root: host.boardDir })));
+			return Responses.layer.pipe(
+				Layer.provide(Workspace.layer),
+				Layer.provide(Layer.succeed(WorkspaceConfig, { changes, index, root: host.boardDir, writable: true })),
+			);
 		}),
 	);
 }

package/src/host/runtime.ts

@@ -51,6 +51,7 @@ export function hostPolicy(host: FleetHost) {
 					operationId: () => crypto.randomUUID(),
 					quota: { expiresAt: 0, observedAt: 0 },
 					readGuidance: (role) => guidance[role].pipe(Effect.mapError((error) => new ServiceUnavailable({ message: error.message }))),
+					readRetryMs: applied.readRetryMs,
 					refreshQuota: refreshQuota(applied),
 					stallMinutes: applied.stallMinutes,
 					...(applied.worker === undefined ? {} : { sharedEnvironment: applied.worker.sharedEnvironment }),

package/src/packageInfo.ts

@@ -1,3 +1,3 @@
 export const NAME = "work-fleet";
 export const TITLE = "Work Fleet";
-export const VERSION = "0.3.0";
+export const VERSION = "0.5.0";

package/src/policy.ts

@@ -120,6 +120,7 @@ export interface FleetConfiguration {
 	readonly operationId: () => string;
 	readonly quota: { readonly available?: number; readonly observedAt: number; readonly expiresAt: number };
 	readonly readGuidance?: (role: "worker" | "reviewer") => Effect.Effect<string | undefined, FleetError>;
+	readonly readRetryMs?: number;
 	readonly refreshQuota?: () => Effect.Effect<FleetConfiguration["quota"], FleetError>;
 	readonly reviewerGuidance?: string;
 	readonly sharedEnvironment?: string;

package/src/scheduling/areas.ts

@@ -27,6 +27,7 @@ function holdsAreas(record: FleetRecord, now: number, mergeWaitMs: number): bool
 	return (
 		!["completed", "released"].includes(record.stage)
 		&& record.attempts.length > 0
+		&& (record.stage !== "prepared" || executing(record))
 		&& record.mergeAreasReleased !== true
 		&& !mergeWaitExpired(record, now, mergeWaitMs)
 	);