@jigs.design/server 0.0.0-stage → 0.1.1

package/dist/session.d.ts

@@ -0,0 +1,7 @@
+import "./design.js";
+import "./compile.js";
+import "./types.js";
+import "@jigs.design/compiler";
+import { Host } from "@jigs.design/host";
+import { Diagnostic, Message, SessionEvent } from "@jigs.design/runtime";
+import { z } from "zod";

package/dist/session.js

@@ -0,0 +1,352 @@
+import { errorData, isPickleError } from "./errors.js";
+import { belowPrefix, pragmaLine, splitPragma, versionDiagnostics, withPragma } from "./pragma.js";
+import { reorderDeclarations } from "./rewrite.js";
+import { addUsage } from "./usage.js";
+import { applyEdits, editBreakage, isEditReply, parseEdits } from "@jigs.design/compiler";
+import { editRepairText, fullDocumentText, needsRepair, repairText } from "@jigs.design/prompt";
+import { z } from "zod";
+const MAX_CONTENT = 2e5;
+const messagesSchema = z.array(z.object({
+	content: z.string().max(MAX_CONTENT),
+	role: z.enum(["user", "assistant"])
+})).min(1).max(200);
+const modelResult = z.object({ usage: z.object({
+	cacheReadTokens: z.number().nonnegative().exactOptional(),
+	cacheWriteTokens: z.number().nonnegative().exactOptional(),
+	inputTokens: z.number().nonnegative(),
+	outputTokens: z.number().nonnegative()
+}) });
+const FENCE_OPEN = /^\s*`{3}[\w-]*\s*$/;
+const FENCE_CLOSE = /^\s*`{3}\s*$/;
+/** The reply without a code fence around it, which models add despite the prompt. */
+function cleanReply(text) {
+	const lines = text.split("\n");
+	const fenced = lines.length > 0 && FENCE_OPEN.test(lines[0] ?? "");
+	if (fenced) lines.shift();
+	while (lines.length > 0 && (lines.at(-1) ?? "").trim() === "") lines.pop();
+	if (fenced && lines.length > 0 && FENCE_CLOSE.test(lines.at(-1) ?? "")) lines.pop();
+	return lines.join("\n");
+}
+/** What an edit reply came to: how many blocks it had and whether they applied. */
+const editResult = (blocks, applied) => applied.ok ? {
+	applied: true,
+	blocks
+} : {
+	applied: false,
+	blocks,
+	reason: applied.reason
+};
+/**
+* Applies `edits` to `base`, and refuses the result when it needs parser
+* repairs the base did not: an edit that leaves a tag unclosed compiles,
+* with the tag closed at the end of the document, which the model did not
+* mean.
+*/
+function applyChecked(base, edits, compile) {
+	const applied = applyEdits(base, edits);
+	if (!applied.ok) return applied;
+	const breakage = editBreakage(compile(base).diagnostics, compile(applied.text).diagnostics);
+	const failed = edits.at(-1);
+	if (breakage.length === 0 || failed === void 0) return applied;
+	return {
+		breakage: breakage.map((repair) => ({
+			line: repair.span.line,
+			message: repair.message
+		})),
+		failed,
+		ok: false,
+		reason: "broken"
+	};
+}
+const lastAssistantBody = (messages) => {
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message?.role === "assistant") return splitPragma(message.content).body;
+	}
+	return "";
+};
+/**
+* One turn. A conversation that ends with an assistant message calls no
+* model: its source is checked and compiled again. Otherwise the model's
+* reply is compiled at each committed line, edits are applied to the last
+* checked source, and errors get up to `maxRepairs` repair rounds.
+*/
+async function* runSession(deps, messages, options, call) {
+	const catalogVersion = deps.host.components.version;
+	/**
+	* Diagnostics as the browser sees them: spans in the sent source, which
+	* starts with the pragma line. The model reads the body without it.
+	*/
+	const belowPragma = (diagnostics) => belowPrefix(diagnostics, pragmaLine(catalogVersion));
+	const errorType = deps.kind === "session" ? "session" : "chat";
+	const started = performance.now();
+	/** What `model` is told: the first answer, or a round that repairs one. */
+	const kindOf = (round) => {
+		if (deps.kind === "chat-repair") return "chat-repair";
+		return round === 0 ? "session" : "repair";
+	};
+	const compile = (body) => deps.checker.compile(body);
+	const placement = deps.kind === "session" ? "document" : "chat";
+	/** Whether a round already asked for the design changes `designRepair` names. */
+	let designRepaired = false;
+	const last = messages.at(-1);
+	if (last?.role === "assistant") {
+		const restored = splitPragma(last.content);
+		const compiled = compile(restored.body);
+		const diagnostics = [...versionDiagnostics(restored.versions, catalogVersion), ...restored.versions === null ? belowPragma(compiled.diagnostics) : belowPrefix(compiled.diagnostics, last.content.slice(0, last.content.length - restored.body.length))];
+		yield {
+			diagnostics,
+			fresh: deps.kind === "session",
+			program: compiled.program,
+			revision: 1,
+			type: "program"
+		};
+		yield {
+			diagnostics,
+			revision: 1,
+			source: restored.versions === null ? withPragma(restored.body, catalogVersion) : last.content,
+			type: "done"
+		};
+		return;
+	}
+	if (deps.model === void 0) {
+		yield {
+			error: {
+				code: "INTERNAL",
+				message: "This server has no model."
+			},
+			type: "error"
+		};
+		return;
+	}
+	const conversation = messages.map((message) => message.role === "assistant" ? {
+		content: splitPragma(message.content).body,
+		role: "assistant"
+	} : message);
+	let current = lastAssistantBody(messages);
+	let revision = 0;
+	/**
+	* Whether the next program starts a new UI: the first one of a session
+	* turn whose answer is a whole document rather than edits. A repair round
+	* fixes the UI the turn started, so it never starts another.
+	*/
+	let startsDocument = deps.kind === "session";
+	let repairs = 0;
+	let editFailures = deps.editFailures ?? 0;
+	let usage = {
+		inputTokens: 0,
+		outputTokens: 0
+	};
+	const rounds = [];
+	let firstProgramMs = null;
+	/**
+	* Notes the first program the browser receives. A chat repair's programs
+	* stay on the server until it is done, so for one that is `done`.
+	*/
+	const shown = (event) => {
+		if (firstProgramMs === null && (event === "done" || deps.kind === "session")) firstProgramMs = Math.round(performance.now() - started);
+	};
+	let finalSource = null;
+	let finalDiagnostics = [];
+	let finalAdvice = [];
+	try {
+		for (let round = 0;; round++) {
+			let text = "";
+			let committed = 0;
+			/** The last program sent, and when; one compiled since waits for the interval. */
+			let lastKey = null;
+			let lastSentAt = Number.NEGATIVE_INFINITY;
+			/** Complete edit blocks already drawn, for an edit reply. */
+			let editsShown = 0;
+			let roundUsage = {
+				inputTokens: 0,
+				outputTokens: 0
+			};
+			const roundKind = round === 0 && deps.kind === "session" ? "answer" : "repair";
+			const iterator = deps.model({
+				ctx: call.ctx,
+				kind: kindOf(round),
+				messages: conversation,
+				options,
+				signal: call.signal,
+				system: deps.system,
+				systemPrefix: deps.systemPrefix
+			})[Symbol.asyncIterator]();
+			try {
+				for (;;) {
+					const step = await iterator.next();
+					if (step.done === true) {
+						const result = modelResult.safeParse(step.value);
+						if (result.success) {
+							roundUsage = result.data.usage;
+							usage = addUsage(usage, roundUsage);
+						}
+						break;
+					}
+					text += step.value;
+					const cut = text.lastIndexOf("\n");
+					const editing = isEditReply(text);
+					if (round > 0 || editing === null || cut <= committed) continue;
+					committed = cut;
+					let body = cleanReply(text.slice(0, cut));
+					if (editing) {
+						const edits = parseEdits(text.slice(0, cut));
+						const applied = applyEdits(current, edits);
+						if (edits.length === editsShown || !applied.ok) continue;
+						editsShown = edits.length;
+						startsDocument = false;
+						body = applied.text;
+					}
+					const compiled = compile(body);
+					const key = JSON.stringify(compiled.program);
+					const now = performance.now();
+					if (key !== lastKey && now - lastSentAt >= deps.programIntervalMs) {
+						lastSentAt = now;
+						lastKey = key;
+						revision++;
+						shown("program");
+						yield {
+							diagnostics: belowPragma(compiled.diagnostics),
+							fresh: startsDocument,
+							program: compiled.program,
+							revision,
+							type: "program"
+						};
+						startsDocument = false;
+					}
+				}
+			} finally {
+				iterator.return?.();
+			}
+			if (call.signal.aborted) return;
+			let source;
+			let edits;
+			if (isEditReply(text) === true) {
+				startsDocument = false;
+				const parsed = parseEdits(text);
+				const applied = applyChecked(current, parsed, compile);
+				edits = editResult(parsed.length, applied);
+				if (!applied.ok) {
+					rounds.push({
+						advice: [],
+						diagnostics: [],
+						edits,
+						kind: roundKind,
+						usage: roundUsage
+					});
+					if (round < deps.maxRepairs) {
+						editFailures++;
+						conversation.push({
+							content: text,
+							role: "assistant"
+						}, {
+							content: editFailures === 1 ? editRepairText(applied, current) : fullDocumentText(applied, current),
+							role: "user"
+						});
+						repairs++;
+						continue;
+					}
+					yield {
+						error: {
+							code: "INTERNAL",
+							message: "The model's edit could not be applied."
+						},
+						type: "error"
+					};
+					return;
+				}
+				source = applied.text;
+			} else source = cleanReply(text);
+			let compiled = compile(source);
+			const reordered = reorderDeclarations(source, compiled, compile);
+			if (reordered !== null) {
+				source = reordered.body;
+				compiled = reordered.compiled;
+			}
+			const diagnostics = belowPragma(compiled.diagnostics);
+			const advice = compiled.advise(placement);
+			const finished = {
+				advice: belowPragma(advice),
+				diagnostics,
+				kind: roundKind,
+				usage: roundUsage
+			};
+			if (edits !== void 0) finished.edits = edits;
+			if (reordered !== null) finished.rewrites = [reordered.rewrite];
+			rounds.push(finished);
+			if (JSON.stringify(compiled.program) !== lastKey) {
+				revision++;
+				shown("program");
+				yield {
+					diagnostics,
+					fresh: startsDocument,
+					program: compiled.program,
+					revision,
+					type: "program"
+				};
+			}
+			startsDocument = false;
+			const chosen = designRepaired ? [] : advice.filter((entry) => deps.designRepair.has(entry.code));
+			if ((needsRepair(compiled.diagnostics) || chosen.length > 0) && round < deps.maxRepairs) {
+				designRepaired ||= chosen.length > 0;
+				conversation.push({
+					content: source,
+					role: "assistant"
+				}, {
+					content: repairText(compiled.diagnostics, chosen),
+					role: "user"
+				});
+				current = source;
+				repairs++;
+				continue;
+			}
+			finalSource = withPragma(source, catalogVersion);
+			finalDiagnostics = diagnostics;
+			finalAdvice = finished.advice;
+			shown("done");
+			yield {
+				diagnostics: finalDiagnostics,
+				revision,
+				source: finalSource,
+				type: "done"
+			};
+			return;
+		}
+	} catch (error) {
+		if (isPickleError(error)) yield {
+			error: errorData(error),
+			type: "error"
+		};
+		else if (!call.signal.aborted) {
+			deps.onError(error, { type: errorType });
+			yield {
+				error: {
+					code: "INTERNAL",
+					message: "The model call failed."
+				},
+				type: "error"
+			};
+		}
+	} finally {
+		if (deps.onTurn !== void 0) try {
+			await deps.onTurn({
+				advice: finalAdvice,
+				completed: finalSource !== null,
+				ctx: call.ctx,
+				diagnostics: finalDiagnostics,
+				firstProgramMs,
+				kind: deps.kind,
+				messages,
+				options,
+				repairs,
+				rounds,
+				source: finalSource,
+				usage
+			});
+		} catch (error) {
+			deps.onError(error, { type: errorType });
+		}
+	}
+}
+//#endregion
+export { MAX_CONTENT, applyChecked, editResult, messagesSchema, runSession };