@shivaedev/work-board 0.17.0 → 0.18.0

package/src/server/document/reviewedWork.ts

@@ -0,0 +1,24 @@
+import { metadataParse } from "#server/metadata/parse.ts";
+
+export const REVIEWED_WORK_HEADING = "## Reviewed Board work";
+
+export function reviewedWork(source: string): string | undefined {
+	const parsed = metadataParse(source);
+	if (parsed.raw === undefined || parsed.diagnostics.length > 0) {
+		return undefined;
+	}
+	const heading = /^\s*#[ \t]+(?<title>.+?)[ \t]*(?:\r?\n|$)/u.exec(parsed.body);
+	const title = heading?.groups?.title ?? parsed.fields.id;
+	const body = parsed.body.slice(heading?.[0].length ?? 0).trim();
+	const criteria = parsed.fields.criteria ?? [];
+	return [
+		[title && `**${title}**`, parsed.fields.id && `\`${parsed.fields.id}\``].filter(Boolean).join(" · "),
+		criteria.length > 0 ? `Criteria:\n\n${criteria.map((criterion) => `- ${criterion.text}`).join("\n")}` : "",
+		body
+			.split("\n")
+			.map((line) => (line.trim() ? `> ${line}` : ">"))
+			.join("\n"),
+	]
+		.filter((block) => block.length > 0 && block !== ">")
+		.join("\n\n");
+}

package/src/server/files/changes.ts

@@ -76,6 +76,7 @@ export const watchChanges = Effect.fn("WorkBoard.watchChanges")(function* (root:
 		setWatching,
 		(paths) => Effect.andThen(invalidate(paths), Effect.andThen(finishPending, publish({ _tag: "Changed", paths }))),
 		observed,
+		finishPending,
 	);
 	yield* attempt.pipe(
 		Effect.sandbox,

package/src/server/files/watchDirectories.ts

@@ -5,6 +5,38 @@ import { isMarkdown, scanMarkdown } from "./list.ts";
 
 const SETTLE = "100 millis";
 
+type WatchRoots = readonly { readonly real: string; readonly relative: string }[];
+
+function changedFiles(previous: ReadonlyMap<string, number>, next: ReadonlyMap<string, number>) {
+	return [...new Set([...previous.keys(), ...next.keys()])].filter((file) => previous.get(file) !== next.get(file));
+}
+
+function sameRoots(previous: WatchRoots, next: WatchRoots): boolean {
+	const known = new Map(previous.map((folder) => [folder.relative, folder.real]));
+	return previous.length === next.length && next.every((folder) => known.get(folder.relative) === folder.real);
+}
+
+function directoryEvent(relative: string, info: Option.Option<FileSystem.File.Info>, roots: WatchRoots, contents: ReadonlyMap<string, number>) {
+	if (Option.isSome(info)) {
+		return info.value.type === "Directory";
+	}
+	return (
+		roots.some((folder) => folder.relative === relative || folder.relative.startsWith(`${relative}/`))
+		|| [...contents.keys()].some((file) => file.startsWith(`${relative}/`))
+	);
+}
+
+function recordFile(contents: Map<string, number>, relative: string, info: Option.Option<FileSystem.File.Info>) {
+	if (!isMarkdown(relative)) {
+		return;
+	}
+	if (Option.isSome(info) && info.value.type === "File") {
+		contents.set(relative, Option.match(info.value.mtime, { onNone: () => 0, onSome: (date) => date.getTime() }));
+	} else {
+		contents.delete(relative);
+	}
+}
+
 export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function* (
 	root: string,
 	realRoot: string,
@@ -12,12 +44,14 @@ export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function
 	setWatching: (watching: boolean) => Effect.Effect<unknown>,
 	publish: (paths: readonly string[]) => Effect.Effect<unknown>,
 	observed: Effect.Effect<void> = Effect.void,
+	settled: Effect.Effect<unknown> = Effect.void,
 ) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const cycle = Effect.scoped(
 		Effect.gen(function* () {
-			const { roots } = yield* scanMarkdown(root, realRoot);
+			const { files, roots } = yield* scanMarkdown(root, realRoot);
+			let contents = new Map(files.map((file) => [file.path, file.modified]));
 			const topology = yield* Deferred.make<void>();
 			// Node's recursive watcher can miss replacement of directory symlinks.
 			const parents = yield* Effect.forEach(
@@ -34,37 +68,66 @@ export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function
 					}),
 				),
 			);
+			// A removed root can be reported without any descendant file events.
+			streams.push(
+				fs.watch(path.dirname(realRoot)).pipe(
+					Stream.filter((event) => event._tag === "Remove" && path.resolve(path.dirname(realRoot), event.path) === realRoot),
+					Stream.map(() => ""),
+				),
+			);
 			const pending = new Set<string>();
+			let rescan = false;
+			const queueRescan = Effect.gen(function* () {
+				if (rescan) {
+					return;
+				}
+				rescan = true;
+				yield* stale;
+			});
+			const changedPath = Effect.fn("WorkBoard.changedPath")(function* (relative: string) {
+				const relevant = isMarkdown(relative) || attachmentType(relative) !== undefined;
+				if (relevant) {
+					yield* observed;
+				}
+				const info = yield* Effect.option(fs.stat(path.join(root, relative)));
+				if (directoryEvent(relative, info, roots, contents)) {
+					if (!relevant) {
+						yield* observed;
+					}
+					yield* queueRescan;
+					return true;
+				}
+				recordFile(contents, relative, info);
+				if (relevant) {
+					pending.add(relative);
+				}
+				return relevant;
+			});
+			const flush = Effect.gen(function* () {
+				if (rescan) {
+					rescan = false;
+					const next = yield* scanMarkdown(root, realRoot);
+					if (!sameRoots(roots, next.roots)) {
+						return yield* Deferred.succeed(topology, undefined);
+					}
+					const snapshot = new Map(next.files.map((file) => [file.path, file.modified]));
+					for (const file of changedFiles(contents, snapshot)) {
+						pending.add(file);
+					}
+					contents = snapshot;
+				}
+				const paths = [...pending];
+				pending.clear();
+				return yield* paths.length > 0 ? publish(paths) : settled;
+			});
 			const watch = Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(
-				Stream.filter(
-					(relative) => !relative.split("/").some((segment) => segment === ".board.sock.starting" || /^\.s[A-Za-z0-9]{6}$/u.test(segment)),
-				),
-				Stream.tap((relative) => (isMarkdown(relative) || attachmentType(relative) !== undefined ? observed : Effect.void)),
-				Stream.tap((relative) =>
-					Effect.gen(function* () {
-						const info = yield* Effect.option(fs.stat(path.join(root, relative)));
-						const removedLink = roots.some((folder) => folder.relative === relative || folder.relative.startsWith(`${relative}/`));
-						if (Option.match(info, { onNone: () => removedLink, onSome: (value) => value.type === "Directory" })) {
-							yield* stale;
-							yield* Effect.forkScoped(Effect.delay(Deferred.succeed(topology, undefined), SETTLE));
-						}
-					}),
-				),
-				Stream.filter((relative) => isMarkdown(relative) || attachmentType(relative) !== undefined),
-				Stream.tap((relative) =>
-					Effect.sync(() => {
-						pending.add(relative);
-					}),
+				Stream.filter((relative) =>
+					relative.split("/").every((segment) => segment === "." || (!segment.startsWith(".") && segment !== "node_modules")),
 				),
+				Stream.filterEffect(changedPath),
 				Stream.interruptWhen(Deferred.await(topology)),
 				Stream.debounce(SETTLE),
-				Stream.runForEach(() =>
-					Effect.suspend(() => {
-						const paths = [...pending];
-						pending.clear();
-						return publish(paths);
-					}),
-				),
+				Stream.runForEach(() => flush),
 				Effect.andThen(
 					Effect.flatMap(Deferred.isDone(topology), (changed) =>
 						changed

package/src/server/handoffs/Service.ts

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { Clock, Effect, FileSystem, Path, Semaphore } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { Conflict, Forbidden, NotFound, PreconditionFailed, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
+import { rpcBoundary } from "@shivaedev/platform/server/rpc-server/boundary.ts";
 import type { Handoff, HandoffInput } from "#browser/handoffs/schema.ts";
 import { markdownPath } from "#server/files/markdownPath.ts";
 import { handoffFrom, handoffMarkdown, handoffPrompt, matchesHandoff } from "#server/handoffs/records.ts";

package/src/server/handoffs/source.ts

@@ -1,6 +1,6 @@
 import { Effect, type FileSystem } from "effect";
 import { BadRequest, NotFound, PreconditionFailed, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
+import { rpcBoundary } from "@shivaedev/platform/server/rpc-server/boundary.ts";
 import type { HandoffPreview } from "#browser/handoffs/schema.ts";
 import type { ResponseRejection } from "#rpc/rejections.ts";
 import { markdownPath } from "#server/files/markdownPath.ts";

package/src/server/http/boardRoutes.ts

@@ -1,6 +1,6 @@
 import { Effect, type FileSystem, type Path, type Scope } from "effect";
 import { HttpRouter, type HttpServerRequest, HttpServerResponse } from "effect/http";
-import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
+import { loopbackOnly } from "@shivaedev/platform/server/rpc-server/local.ts";
 import type { Diagnostics } from "#diagnostics/source.ts";
 import { responseUrl } from "#responses/url.ts";
 import type { BoardOptions } from "#server/board.ts";

package/src/server/packageInfo.ts

@@ -1,2 +1,2 @@
 export const NAME = "work-board";
-export const VERSION = "0.17.0";
+export const VERSION = "0.18.0";

package/src/server/render/Highlighter.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { createHighlighter } from "shiki";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { codeBlocks, THEMES } from "#render/code.ts";
 import { RenderFailed } from "#render/Failed.ts";
 

package/src/server/responses/locate.ts

@@ -1,6 +1,6 @@
 import { Effect, type FileSystem } from "effect";
 import { BadRequest, NotFound, PreconditionFailed, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
+import { rpcBoundary } from "@shivaedev/platform/server/rpc-server/boundary.ts";
 import type { QuestionPreview } from "#browser/responses/schema.ts";
 import type { ResponseRejection } from "#rpc/rejections.ts";
 import { currentDocument } from "#server/currentDocument.ts";

package/src/server/rpc/handlers.ts

@@ -1,7 +1,7 @@
 import { Effect, Layer, Ref, Stream } from "effect";
 import { InternalServerError, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
-import { requestTracingLayer } from "@shivaedev/platform/rpc-server/tracing.ts";
+import { rpcBoundary } from "@shivaedev/platform/server/rpc-server/boundary.ts";
+import { requestTracingLayer } from "@shivaedev/platform/server/rpc-server/tracing.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import { DocumentRejection, ResponseRejection } from "#rpc/rejections.ts";
 import { HandoffsService } from "#server/handoffs/Service.ts";

package/src/server/serve.ts

@@ -1,7 +1,7 @@
 import { Context, Deferred, Effect, Layer, Path } from "effect";
 import { HttpServer } from "effect/http";
 import * as NetAddress from "effect/net/NetAddress";
-import { appHost } from "@shivaedev/platform/appHost.ts";
+import { appHost } from "@shivaedev/platform/server/appHost.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import type { Server } from "#rpc/Server.ts";
 import { boardRuntime } from "#server/boardRuntime.ts";

package/src/server/workspace.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, FileSystem, Path, type PlatformError } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import type { Document } from "#browser/document/schema.ts";
 import { readDocument } from "#server/document/read.ts";
 import type { Changes } from "#server/files/changes.ts";

package/dist/client/page/resolvedDocumentFailure.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolvedDocumentFailure.d.ts","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAqB,MAAM,QAAQ,CAAC;AAElD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAG5E"}

package/dist/client/page/resolvedDocumentFailure.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolvedDocumentFailure.js","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAElD,MAAM,UAAU,uBAAuB,CAAC,KAA2B;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,OAAO,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AACvF,CAAC"}

package/dist/client/page/routeQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"routeQuery.d.ts","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,UAAU,OAAO;IAChB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;CACnE;AAED,eAAO,MAAM,iBAAiB;IAAK,UAAU;CAAU,CAAC;AAExD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6TAEtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,CAAA;CAAE;;;;;;;;;;;;+HAE9G"}

package/dist/client/page/routeQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"routeQuery.js","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;AAExD,MAAM,UAAU,aAAa,CAAC,GAAY,EAAE,GAAW;IACtD,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAA+E;IAC9G,OAAO,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACjE,CAAC"}